<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Tori Huang on Medium]]></title>
        <description><![CDATA[Stories by Tori Huang on Medium]]></description>
        <link>https://medium.com/@tori_huang?source=rss-3cc5c6024db0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*l8iHqgUD5f0Ti2MVbtyChg.jpeg</url>
            <title>Stories by Tori Huang on Medium</title>
            <link>https://medium.com/@tori_huang?source=rss-3cc5c6024db0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 15:41:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tori_huang/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Gusto Went to LDX3 NYC]]></title>
            <link>https://engineering.gusto.com/gusto-went-to-ldx3-nyc-d06db21cde62?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/d06db21cde62</guid>
            <category><![CDATA[ldx3]]></category>
            <category><![CDATA[conference]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-leadership]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 21:56:02 GMT</pubDate>
            <atom:updated>2026-10-05T23:31:06.107Z</atom:updated>
            <content:encoded><![CDATA[<p>In September, Gusto attended <a href="https://leaddev.com/leaddev-new-york/">LDX3 NYC</a> — a conference entirely dedicated to leadership in tech. There were managers, directors, tech leads, and senior engineers. Attendees jumped between the technical and management stage, learning about “Re-engineering the software development playbook” on the management stage one hour and “How to kill the code review” on the technical choices stage the next.</p><p>The one thing we had in common: everyone there was invested in learning how to become a better leader.</p><figure><img alt="A group of six Gusties having snacks and drinks at a restaurant" src="https://cdn-images-1.medium.com/max/1024/1*y8r3o8jos2ykSxHkbnnBUg.jpeg" /><figcaption><em>📸 Pictured left to right: Kamilah Taylor, Vianca Martinez, Tori Huang, Rebecca Borison, Irina Khafizova, Anshuma Chandak (and Alyssa Hester here in spirit!)</em></figcaption></figure><p>Because, of course, AI. Everything is changing and we need to adapt. Are code reviews dead? Does my team structure and processes still make sense? How do I harness the power of these new tools while maintaining (even raising) our code quality bar? What must be dismantled? Rebuilt? Protected? So many open questions. That means we need leadership now more than ever. That need doesn’t sit just at the director level. It’s at <em>every</em> level, on <em>every</em> team.</p><p>Hello 👋 I’m Tori (in the back with the white flower earrings). I’m a Senior Staff Software Engineer at Gusto, and LDX3 was one of the coolest conferences I have ever attended. I loved it — new ideas, new connections, and most importantly, meeting and learning from folks who are all navigating similar challenges.</p><p>Part of this conference, for me, was sitting in a room full of people who are also just figuring it out. There is something extremely reassuring about sitting in a talk titled “Tackling the junior developer crisis in the age of AI,” with a bunch of other engineers who are <em>also</em> concerned. Who <em>also</em> don’t know with full certainty what to do next, but who are determined to figure it out.</p><p>So here are some takeaways, from all of us Gusto attendees, on what we learned and how it will shape our work moving forward.</p><figure><img alt="LDX3 by LeadDev festival welcome sign. It reads, “the festival for modern engineering leadership.”" src="https://cdn-images-1.medium.com/max/1024/1*Zcfkfk3pBvXGGyJdipDd7w.png" /></figure><h3>Kamilah Taylor, Head of Mobile Core Engineering</h3><p>I knew going in that a lot of talks would circle around AI, and I was certainly quite curious to see what the sentiment was across the industry and how others were working through different challenges. Some things that I’m reflecting on:</p><p><strong>Some new problems are old problems.</strong> In many of the Director+ roundtables and discussion groups, even if the jumping off point was how is AI impacting x, we usually ended up discussing this in a very similar way as we would have pre AI. A great example of this was in the managing managers discussion, where we found that we had very similar challenges that we needed to work through when scaling our engineering leadership as we did a few years ago.</p><p><strong>Everyone is overwhelmed with increased volume.</strong> Increased volume of what? Well, everything. More PRs, more docs, easier access to more data. I thought Camille Fournier’s <a href="https://skamille.medium.com/the-managers-path-in-the-age-of-ai-279cb6611d66">insights</a> here were especially interesting — there’s a huge temptation to just always ask AI for data or summaries. “Visibility is up but understanding is not.” We still need to exercise judgement here on when to use AI, and when we need to spend the time to understand what we’re trying to summarize, or to talk to people versus the temptation to ask AI to answer all the questions for us. On the management side, we’re ultimately accountable for these decisions, and this is the same on the engineering IC side, so it is important to still keep those skills sharp.</p><p><strong>Specializations still matter even in a world where code is cheap.</strong> I had some great conversations with others in the mobile space about how we’re thinking about mobile specialists and mobile app development. I’ve long been a believer that leaning into these platform specialists and native apps produces higher quality experiences for users. With AI reducing the time to produce code, it reinforces why native investment still pays off.</p><h3>Rebecca Borison, Retirement Engineering Manager</h3><p>Not surprisingly, a lot of the talks this year revolved around how to better work with AI, but it was super interesting to hear how other companies were thinking through the same challenges we’re seeing at Gusto.</p><p>Here are a few of the things that stuck with me:</p><p><strong>Speed without judgement is just risk.</strong> Some parts of a system are fine to move fast and loose on: UI, boilerplate, low-stakes experiments. Others need a human slowing things down on purpose: anything touching money, security, or decisions that are hard to unwind. The question isn’t “should we use AI to go faster,” it’s “where is going faster actually safe.”</p><p><strong>Output is not the same as impact.</strong> This came up again and again, especially from engineering leaders being asked to justify AI spend: lines of code, tickets closed, and raw velocity are easy to measure and easy to game, and they don’t tell you whether the work actually helped anyone. The better question is whether friction went down for the people using what you built, and whether it moved something that mattered to the business. That’s true whether you’re an engineer, a designer, or a PM — it’s easy to feel productive without being useful.</p><p><strong>The skills that matter are shifting toward the human ones.</strong> As AI takes over more of the routine work, the thing that’s left to us is understanding the real problem: talking to the people affected, having the context to know what “good” looks like, and using judgement about tradeoffs. The differentiator isn’t how fast you can produce something anymore, it’s whether you understood the problem in the first place.</p><h3>Vianca Martinez, Symmetry Software Engineer</h3><p>We are all navigating the same challenges with AI. With a new way to “AI” every day, I often felt like I was behind; hearing others wrestle with the same questions around code reviews, developing the next generation of engineers, and adapting to a changing SDLC helped quiet some of that imposter syndrome.</p><p>My key takeaways were that as code becomes cheaper and easier to produce, the value of an engineer is shifting away from simply writing code and more toward planning, defining intent, setting the right guardrails, and <strong>validating that we’re solving the right problems</strong>. We’re moving toward an SDLC where specs and tests become increasingly important, agents are trusted to work through more of the development cycle independently, and our job becomes less about babysitting AI and more about <strong>giving it the right context and tools to succeed.</strong></p><p>Another interesting tension was around the next generation of engineers. Junior software engineering hiring is declining industry-wide., yet we’ll still need to cultivate the next generation of strong, AI-native engineers who can eventually become our senior engineers and technical leaders. If AI is changing how engineers learn and gain experience, then we also have to <strong>rethink how we create those opportunities</strong> and develop strong engineering judgement along the way.</p><p>Most importantly, AI fluency isn’t about keeping up with every new tool; it’s about learning how to adapt our engineering practices around it.</p><figure><img alt="Presentation that reads “Talk to people more than Claude” with a few participants watching, seating in the foreground." src="https://cdn-images-1.medium.com/max/1024/1*RbNNWRk6ETnAInkSI9wJjw.png" /></figure><h3>Anshuma Chandak, Senior Staff AI/ML Engineer</h3><p><strong>Reality check: LLMs are powerful, but the workflow matters</strong></p><p>One of the clearest themes was a more grounded understanding of LLM limits. Because outputs are stochastic, they’re hard to trust for deterministic decision-making. Instead, the more durable pattern is using AI to build tools and workflows that help people make better decisions. This is better than treating “agentic AI” as something that should run wild and autonomously figure everything out.</p><p><strong>Context remains the hardest unsolved piece</strong></p><p>Many teams still don’t have a settled best practice for giving models the right context. It is not uncommon to see teams leaning on brute-force approaches like putting large amounts of text into the context window. There isn’t yet a consistent definition of what “good context” looks like or how to make it reliable and repeatable.</p><p><strong>Impact is shifting from activity metrics to outcomes</strong></p><p>There was also a noticeable move away from measuring engineering productivity through proxies like PR count or tokens consumed. More organizations are asking teams to connect work to outcomes like what changed for users or the business, since raw activity is easy to optimize (and game) without necessarily creating meaningful impact.</p><h3>Irina Khafizova, Gusto Pro Engineer</h3><p><strong>Key takeaways from LeadDev</strong></p><p><strong>AI makes code cheaper, so engineering judgement, context, and guardrails matter more.</strong> A lot of the conversation was about shifting review and rigor upstream, turning repeated learnings into systems, and keeping business context (and knowledge sharing) front and center.</p><ul><li><strong>Review decisions, not just diffs.</strong> Push review earlier: intent, acceptance criteria, architecture, assumptions, and tradeoffs. Treat the PR as evidence of decisions, not the decision record.</li><li><strong>Automate recurring feedback.</strong> Turn “we always comment on this” into a test, lint rule, constraint, agent instruction, or automated check.</li><li><strong>Scale autonomy with risk.</strong> Decide how much autonomy is OK based on blast radius, reversibility, error tolerance, and cognitive complexity.</li><li><strong>Use multiple agents to surface ambiguity.</strong> Independent proposals/reviews can highlight disagreements — often the signal that requirements or assumptions are unclear.</li><li><strong>Preserve knowledge sharing.</strong> Reviews and pairing also build shared understanding; don’t automate that benefit away.</li><li><strong>Lean on domain knowledge.</strong> As implementation gets easier, “why this exists” (constraints, failure modes, history, what matters) becomes a bigger part of impact.</li><li><strong>Match rigor to risk.</strong> Not every change needs the same process; calibrate with complexity, potential damage, reversibility, and failure tolerance.</li><li><strong>Anchor technical choices in business context.</strong> The “best” technical solution isn’t always the right one; weigh value, cost, and opportunity cost.</li></ul><p><strong>TL;DR</strong></p><p><strong>AI changes where we spend time, not the need for judgement.</strong> Let automation handle more implementation and repetitive verification; keep humans focused on intent, architecture, risk, and the decisions behind the code.</p><h3>Alyssa Hester, Senior Staff Consumer Money Engineer</h3><p><strong>Documentation for the win</strong></p><p>In a world where the implementation details matter less, the what, the why and the core non-functional system requirements become more important. Clear, crisp documentation is required, now more than ever. We can lean into documentation to validate system correctness and user experience as we continue to build rapidly with agents. Documentation preserves decision history and reasoning, something quickly lost within code given the new rate of change.</p><p><strong>Fundamentals aren’t going away</strong></p><p>We should continue focusing on improving our core platform including guard rails, CI/CD, and other platform work. This helps humans <em>and</em> agents. Test driven design, listing system invariants to clearly state what a system should do, and leaning in to domain driven design can both help us think more clearly and provide context for agents that leads to better results.</p><p><strong>Be open to experimentation</strong></p><p>How we work has to change. There won’t be a one size fits all model but we should continue to embrace curiosity, dropping ways of working that no longer serve us. Be willing to try something new.</p><p><strong>30 min MBA summary — a non AI talk</strong></p><p>One talk focused on summarizing an executive MBA program to thirty minutes. I’ll summarize even further to just one point: think of engineering work and technical projects as investments. As engineers we often understand the importance on a low level, but how does this translate into business health? Going through this exercise can help align engineering with other stakeholders and create tangible business impact.</p><figure><img alt="Two Gusties smiling side by side and holding up “Broad Strokes” musical comedy showbills." src="https://cdn-images-1.medium.com/max/800/1*Vdy7KPYgSHNaoH9RR1QNSA.jpeg" /><figcaption><em>📸 Pictured left to right: Tori Huang, Alyssa Hester, doing NYC stuff after Day 1 at the conference</em></figcaption></figure><h3>Tori Huang, Senior Staff Payroll Engineer</h3><p>Hello, it’s me again.</p><p>My teammates have covered the bases. We learned everything from practical advice on working with AI in our day to day, trends in where tech is heading, and how to continue to stay ahead of these changes.</p><p>The biggest takeaway for me was: the only guarantee over the next six months is more change. In the midst of all these transformations, we need people to guide us at every level. It was pretty cool to be there with a bunch of other people learning how to be better leaders for their teams.</p><p>If you are one of these people, or simply trying to navigate how quickly our industry is changing, LeadDev is worth attending. You’ll leave with new ideas, connections, and fresh energy for what comes next. Thanks for an awesome time, LeadDev, hope to see you at the next one! 💖</p><p><em>Leadership matters at every level, and we’re hiring for it. Explore engineering roles at </em><a href="https://gusto.com/about/careers"><em>gusto.com/about/careers</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d06db21cde62" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/gusto-went-to-ldx3-nyc-d06db21cde62">Gusto Went to LDX3 NYC</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Gusto is heading to RailsConf 2024 in Detroit!]]></title>
            <link>https://engineering.gusto.com/gusto-is-heading-to-railsconf-2024-in-detroit-9b01d34db7c2?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b01d34db7c2</guid>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[ruby-on-rails-development]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Mon, 29 Apr 2024 17:02:12 GMT</pubDate>
            <atom:updated>2024-04-29T17:02:12.151Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Illustration of folks collaborating both remotely and in person." src="https://cdn-images-1.medium.com/max/1024/1*029481ehpPAa5hV3fqMNTQ.png" /></figure><p>At Gusto, we empower over 300,000 businesses to hire, pay, and manage their teams. This includes services such as payroll, health insurance, 401(k)s, expert HR, and team management tools. <em>All</em> of these platforms use Ruby on Rails as their backends.</p><p>We are very excited to join <a href="https://railsconf.org/">RailsConf 2024</a> and support this community as a gold sponsor. If you’ll be at the conference, we’d love to connect!</p><h3>Where you’ll find us</h3><p><em>All week at Booth #8, near the Ruby Cafe</em></p><p>Come find us at the Gusto booth. We’ll have yard games, giveaways and some very cozy couches where you can take a breather and charge your devices before hitting up your next talk. Have you worked in a Rails monolith before? Do you want to chat about modularity or tools like Packwerk and the RubyAtScale ecosystem we built around it? Are you curious about using Gusto at your company? Don’t hesitate to come say hello!</p><h3>Gusto Spark Sessions — Lighting Talks by Gusto Engineering</h3><p><em>Tuesday, 2:00 pm — 2:45 pm in Room 141</em></p><p>Curious what we’re building? Join us on Tuesday to hear about a variety of topics including modularity, hiding complexity with the right API, improv comedy and software engineering, and more.</p><h3>Vision for Inclusion workshop</h3><p><em>Wednesday, 2:30 pm — 4:30 pm in Room 142 A-C</em></p><p>This interactive workshop, led by Todd Sedano and Kevin Lawver from Gusto, will be centered around real, personal stories from across the industry pertaining to feelings of inclusion or exclusion. Several of the stories describe how discrimination affected the story’s author. The goal is to challenge participants to continue to create an inclusive engineering culture at their company. We hope to shine a light on some of the subtle behaviors that can unknowingly lead to others feeling excluded.</p><h3>Open source hack day</h3><p><em>Wednesday, 10:30 am — 5:00 pm in Ballroom A</em></p><p>Are you interested in how Gusto uses or contributes to open source projects? Come hack with us! A group of Gusto engineers will be participating and we’d love to work with you.</p><h3>Job fair</h3><p><em>Thursday, 10:45 am — 12:40 pm in Room 140 A</em></p><p>Gusto is hiring!</p><p>Check out our <a href="https://gusto.com/about/careers/join-the-team">open roles</a>. If you have any questions, please don’t hesitate to get in contact with our People team. If you’re interested in Gusto and will be at RailsConf, come say hi at the Gusto booth.</p><h3>Gusto 💖 Rails</h3><p>Although we have a variety of tools in our tech stack, Rails is our foundation. There are many Rails topics we love to chat about, but here are a few we are particularly looking forward to digging into with other engineers:</p><ul><li>Modularity in a Rails monolith</li><li>Performance</li><li>Sidekiq</li><li>GraphQL</li><li><a href="https://medium.com/gusto-engineering/laying-the-cultural-and-technical-foundation-for-big-rails-6b5ab78349ed">Laying the Cultural and Technical Foundation for Big Rails</a></li></ul><p>For more details on how we use Rails at Gusto and the types of problems we work on, check out our <a href="https://medium.com/gusto-engineering/tagged/ruby-on-rails">engineering blog</a>.</p><p>See you at RailsConf 👋</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b01d34db7c2" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/gusto-is-heading-to-railsconf-2024-in-detroit-9b01d34db7c2">Gusto is heading to RailsConf 2024 in Detroit!</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bust through analysis paralysis]]></title>
            <link>https://engineering.gusto.com/bust-through-analysis-paralysis-114c54553309?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/114c54553309</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[decision-making]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Mon, 14 Feb 2022 19:20:23 GMT</pubDate>
            <atom:updated>2022-02-15T17:43:01.154Z</atom:updated>
            <content:encoded><![CDATA[<h4>How to make tough software decision with a decision matrix</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZPBrsTPpZJzn2_qkr7VjpA.png" /></figure><p>Changes within a monolith can have far reaching, unintended consequences. This makes it extremely difficult, if not downright impossible, to safely make foundational changes to a system. At Gusto we’ve been building towards a modularized monolith, but we still have some work to do.</p><p>When my team decided to tackle a project that would fundamentally alter the way we reconcile taxes, there were a few concerns. How does a payroll engineering organization give the green light for a basal change to their tax system when the consequences reach many domains, features, and teams?</p><p>For a few weeks we circulated the problem to various engineering teams. We asked for input and our repository of creative solutions continued to grow. After a few weeks, despite the engaging conversation, we were left with many potential solutions to shipping this change but no clear answer as to how to decide between them. Each solution had benefits, but each also came with non-negligible risks.</p><p>This type of analysis paralysis has the ability to seriously slow down a project, or even bring it to a complete halt. Luckily, my manager <a href="https://medium.com/u/839faeb62d10">Yannick Dawant</a> suggested we consider using a decision matrix. With a decision matrix we were able to break down our options, clearly compare solutions, and find a path forward.</p><h3>How to build a decision matrix</h3><p>A decision matrix is a tool that provides a weighted comparison between many options. When there are many different factors and risks to consider, but there can only be one path forward, a decision matrix is a great way to analyze many options and find consensus as a team.</p><h4>Define the evaluation criteria</h4><p>Instead of starting with solutions, start with the evaluation criteria. The first step to building a decision matrix is clarifying the metrics of a successful project. With our tax reconciliation project, for example, the most obvious criteria for success was that the work improved tax accuracy. Upon further consideration we realized it was also important that the impact to the change was predictable. We had a strict timeline for the project. Our team would like all of our projects to move us towards our long term goals.</p><p>After carefully considering what would make this tax reconciliation project successful, we were able to come up with these requirements:</p><ul><li>Change improves tax accuracy</li><li>Impact is predictable</li><li>Change is reversible</li><li>Change is not noticeable to customer in app</li><li>Project can be completed within two months</li><li>Solution moves us towards our other long term goals</li></ul><p>As this is a highly technical decision, many of the criteria came from engineers. However we also gathered some critical requirements from cross-functional stakeholders. Customer facing stakeholders were able to provide input our engineering team had not considered.</p><h4>Weight the evaluation criteria</h4><p>Listing out your evaluation criteria is a helpful first step, however each criteria does not carry equal weight. For example, while our team would prefer a solution that “moves us towards our long term goals”, we care <em>much</em> more that the “change is not noticeable to the customer in app”.</p><p>The next step to a decision matrix is weighting each of your listed criteria. Each criteria carries a different level of importance and our decision matrix needs to reflect this. You can select any range to apply weighted values. Our team chose 1–10, with 1 being the least important and 10 being the most important.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*T0AfFAioNkQzq-EL.png" /></figure><p>Defining and weighting the criteria should be a team activity. Discussing what success looks like for the project will bring uncertain areas to light and give the team an opportunity to clarify incongruences early on.</p><h4>Rank the solutions against each criteria</h4><p>Once the evaluation criteria are clearly defined and weighted, the team can score each solution against each criteria. We allowed for scores 0–3, with 0 meaning the option does not fulfill the criteria and 3 meaning the criteria is very likely to fulfill the criteria.</p><p>When completing the ranking process we wanted to avoid <a href="https://en.wikipedia.org/wiki/Anchoring_(cognitive_bias)">anchoring bias</a>, the tendency for humans to be influenced by the first piece of information they hear. Each teammate completed the ranking process solo in order to ensure as little bias as possible. We then came together to discuss each evaluation criteria ranking vs each option and agree on a ranking as a team. This was a lengthy process and should not be rushed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VE3NTMC1-n8dt1Vh" /></figure><p>Calculate the final solution score by multiplying each criteria weight by the solution ranking for that criteria and adding together the total.</p><p>solution_score = sum_for_each_criteria(weight * solution_ranking)</p><p>We finally had it. Our solutions were scored by weighted criteria and our path forward was clear.</p><h3>Make a decision and keep building</h3><p>With the help of a decision matrix, my team was able to make a fundamental change to our tax system. We do not build software in black and white. Any complex (and therefore interesting!) problem typically comes with a multitude of potential solutions, all with unique benefits and risks. A decision matrix is a powerful tool for teams to bust through their analysis paralysis, see the problem clearly, and find a path forward.</p><p>Have you used a decision matrix before? Do you have other tools you use to make complicated software decisions? Share them in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=114c54553309" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/bust-through-analysis-paralysis-114c54553309">Bust through analysis paralysis</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cultivating Engineering Growth]]></title>
            <link>https://engineering.gusto.com/cultivating-engineering-growth-419c5cfc8779?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/419c5cfc8779</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[tech-lead]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[senior-engineer]]></category>
            <category><![CDATA[career-development]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Wed, 22 Sep 2021 22:10:52 GMT</pubDate>
            <atom:updated>2024-06-25T19:11:20.372Z</atom:updated>
            <content:encoded><![CDATA[<h4>How tenured engineers helped me along my path to senior engineering</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0ZhbU4QlruaVlotC.jpg" /></figure><p>Investing in engineering growth is a cultural decision that can have an enormous impact on retention, happiness, and long-term company scalability. Senior engineers are a crucial component to cultivating engineering growth on any team.</p><p>As someone who was recently promoted to senior engineer, this journey is still fresh in my mind. Here are some ways that senior engineers have helped during my career path from junior to senior engineer.</p><h3>Building Trust</h3><p>My most valued relationships with senior engineers all have one thing in common — trust.</p><p>The very first step to building a culture of growth on your team is fostering trust amongst all team members, especially the junior engineers. When your teammates are comfortable asking “stupid questions”, making mistakes, and even failing, they will learn more quickly.</p><h4>Share your own mistakes</h4><p>How do you help others feel comfortable making mistakes? By being honest about your own experiences, especially your failures.</p><p>In my first job as a software engineer, I had weekly 1:1s with an engineer with decades of experience. He had built and sold a company to LinkedIn. His experience was so far beyond my own that following in his footsteps seemed completely unattainable. I was constantly nervous around him and worried about asking stupid questions (see:<a href="https://www.geeksforgeeks.org/imposter-syndrome-in-software-developers-am-i-a-fake-developer/"> imposter syndrome</a>).</p><blockquote><em>This was unfortunate — the ability to ask questions is an engineer’s most valuable skill.</em></blockquote><p>My false image of him as “all-knowing” was shattered when he shared a story about meeting one of the original creators of Netscape, Marc Andreessen, at a party in college. They got to chatting about the internet and its potential. This engineer told the creator of Netscape that, while the internet was <strong>very</strong> cool, it would never take off.</p><p>That story of him saying something so completely wrong was (1) very funny and (2) made me vastly more comfortable being wrong myself. While I was still nervous asking questions, this story splintered my incorrect view of him. It made him human. It made me more comfortable asking “stupid questions”.</p><h4>Say “I don’t know, but here’s how we’ll find out”</h4><p>When I first started at Gusto, I had very little experience working with senior engineers on a daily basis. I thought that any problem I worked on would be trivial to a senior engineer and that they would immediately have the answer.</p><p>After a day of struggling with a difficult ticket, I decided it was time to ask a senior engineer on my team for help. He dropped what he was doing, and we started pairing. I observed his investigation process as he learned more about the problem. He used methods I had not seen before to find the root cause of the bug.</p><p>I learned much more by watching my teammate investigate the problem than I would have if he’d immediately solved it without going through each step. Teaching how to debug, investigate, thoroughly think through code — this is the most valuable type of pairing for junior engineers. Going through this process with your teammates and being honest when you don’t immediately have an answer will continue to build trust on your team. Think “we do not have the answers, but we will find them together.”</p><h4>Understanding some teammates have additional obstacles</h4><p>Some teammates have additional obstacles.</p><p>My first job out of college was as a mechanical engineer. After two years, I quit due to sexism and sexual harassment. That experience set me up to go into every new job with a fear that my coworkers will immediately judge me as less competent and might even exclude me from meetings or important decisions. I felt I would need to work twice as hard to be respected.</p><p>After starting at Gusto, I had my first 1:1 with the most senior engineer on our team (a team of two white men, and now me). The same fear was there — “would my gender be a problem on this new team?” However, in an unexpected twist, it was something this senior engineer was thinking about as well.</p><p>During the 1:1, my new teammate acknowledged that our little team was seriously lacking in diversity. His exact wording was “I know we’re a team of white guys from the midwest.” He then assured me that he was happy I was joining the team, that they will really benefit from having some diverse perspectives, and that they were lucky to have me.</p><p>I can’t explain how far those few sentences went in terms of making me comfortable on this new team. From that reassurance, I knew he had spent time thinking about joining the team from my perspective. He was aware I might feel strange as the only woman on the team. Most importantly, I knew it mattered to him that I felt welcome and included. Several months later I was ingrained in the team and we had grown to include more engineers from under represented groups. The culture created by our manager and the senior engineers allowed me to shift my focus away from a fear of other people’s biases and towards learning while building cool software.</p><p>It’s important to note, not every engineer would want their other-ness to be called out in this way. While it helped me, it might not help others.</p><p>Underrepresented groups in tech have additional obstacles as engineers. You are not going to solve systemic sexism, racism or prejudice on your own, but you can do the work to help understand the additional obstacles your teammates face. You can bring that understanding into your relationships at work. Checkout the list of resources at the bottom of this article for easy ways to start learning more.</p><h3>Providing opportunity</h3><p>Engineers cannot advance to more senior positions without projects that expand their comfort zone. Senior engineers are in a unique position to help junior engineers grow. Senior engineers have power on the team. They have influence over what work the team takes on and who works on those projects.</p><p>They also know where opportunity hot spots lie within the code. Every senior engineer I know has an unofficial back-of-their-mind list of projects they would like to see completed. They could partner on this work with a more junior engineer or even support their teammate to lead the project.</p><h4>Recognize their goals</h4><p>Before you can provide an opportunity to grow, you must understand your teammate’s career goals. What are their short term goals — are they interested in learning more about a specific language, domain, or other skill? How about long term goals — do they want to stay technical, become a manager, or something else entirely? Once you understand what their goals are, you can keep an eye out for ways to get them involved with relevant projects.</p><h4>Provide opportunity and support</h4><p>I would not have been promoted to senior engineer at Gusto without this type of opportunity, supported by the senior engineers on my team. When I was working towards my senior engineering promotion, my manager identified that he needed more signal about my ability to take a poorly defined project and return results. This was frustrating as I believe is one of my strengths. However, even if I had displayed this skill at previous companies, I had not had the opportunity to do so at Gusto.</p><p>In this case, senior engineers and my manager worked together to create time and space for me to take the lead on <a href="https://medium.com/gusto-engineering/build-what-matters-1cfd1e6d886d">a project</a> to connect small businesses on Gusto with our Gusto Partners, skilled accountants and bookkeepers. My manager dreamed up the project idea and provided the necessary resources for me to make it happen. The most senior engineer on my team helped create separate work streams that allowed me to focus on this promotion case project while the rest of the team focused on our other OKRs. Another senior engineer on the team partnered with me on the project, working with me on a daily basis.</p><p>Without this project I would not have met the requirements for promotion and likely would have been passed over. I would have grown frustrated — I probably would have quit. This opportunity for growth gave me a chance to learn while proving my engineering abilities. In this scenario, my manager and the senior engineers not only helped me learn, they kept me at the company.</p><h4>Rotate project lead</h4><p>One of my favorite processes for promoting learning throughout the team is rotating the project lead. Project lead is the engineer responsible for the initial investigation into technical complexities, creating JIRA tickets, and ultimately ensuring the project is completed. The ability to investigate and plan a project is a crucial engineering skill. Taking turns supporting your teammates on their projects fosters a sense of camaraderie. This is an easy way to use your team process to provide growth opportunities for all teammates regardless of seniority.</p><h4>Unblocking</h4><p>Sometimes being stuck on a particularly tricky bug is a learning opportunity, but other times it is just demoralizing. This is especially true for junior engineers working hard to prove themselves.</p><p>Being stuck does not exclusively mean being unable to debug a problem. There have been times I was blocked when considering trade offs related to best practices or architecture decisions. Some decisions are difficult to make without experience and can be made much more effectively with timely input from more tenured engineers.</p><p>As a senior engineer, you have the power to unblock your teammates. Supporting your team and keeping everyone unblocked should be a senior engineer’s top priority.</p><p>If you’re reading this and thinking, “This is impossible. If I were to follow this advice I would never get anything done” consider whether you are being properly supported as a senior engineer. You should be able to work as a senior engineer, spend significant heads down time on your own projects, while also making time to support the more junior engineers on your team. If this is not the case, do you need more senior engineers? Do you need more mid level engineers? An imbalance between time to support your more junior teammates and heads down time for yourself is a red flag that your team needs more midlevel and / or senior engineers.</p><h4>Create time to learn</h4><p>As engineers we are constantly learning. If the more junior engineers on your team see you taking the time to learn, to investigate code thoroughly, to read or attend conferences, they will feel comfortable doing the same.</p><p>At my first two jobs as a software engineer I had very little (and sometimes no) help from senior engineers. This led to an incorrect view of what it meant to be a senior engineer. I thought a more talented senior engineer was constantly producing work. Senior = faster. At Gusto I saw this was not exactly the case. Of course, the more senior engineers can build very quickly. This was not what made them better engineers. The senior engineers were taking time to learn new things, read about best practices, and discuss ideas.</p><p>It can be incredibly difficult to find time to learn at a company, especially at startups. There is so much pressure to constantly produce. However, I have seen that tenured engineers carve out time for themselves to be heads down, to learn and explore. The most talented engineers I know understand how they learn best and create that space for themselves.</p><p>Lead by example. If you take time every Friday to study or read articles, let your team know. If you need heads down time every week to dig into code related to long term projects, put it on your calendar. Tell your team what you’re doing. The more junior engineers on your team are building the skill of creating time to learn. Being transparent about how you make this possible for yourself is crucial to helping them create time to grow as well.</p><h3>Real Feedback</h3><p>Feedback is hard, but it is the fastest way to learn what you are doing well and where you need to improve. Feedback from the senior engineers on a team carry an enormous amount of weight. One of my teammates still remembers feedback she received from one of the more senior engineers at our company. He left positive feedback on her PR for a refactor she completed. She remembers the PR, the project, and the exact words he said. As a senior engineer, your feedback has a huge impact.</p><p>It takes considerable time, effort, and emotional energy to provide real feedback, but it means the world to your teammates and will greatly impact their growth. These are some questions I ask myself before providing feedback for teammates.</p><ul><li>Imagine the engineer at the next level — what qualities would she need in order to meet expectations at that level?</li><li>What would be missing from your team if this engineer left? Both technically and culturally.</li></ul><p>While I am now a senior engineer myself, I know I have not perfectly followed every one of my own recommendations. Being a senior engineer is hard work and I am still learning myself. However, I do aspire to help my teammates in the same way other engineers have helped me.</p><p>This article is, of course, only half of the senior &lt;&gt; junior equation. In order for this relationship to work, junior engineers need to be curious, ask questions, and look for ways to learn and grow.</p><p>I consider it the responsibility of the senior engineer to set the culture at a company, on their team, and within relationships with their more junior teammates. These are the things that helped me on my journey to becoming a senior engineer. Do you have anything to add about ways senior engineers have helped you? I would love to hear about them in the comments below.</p><h3>URG resources</h3><p>This is not a comprehensive list — just a few resources to get you started.</p><ul><li><a href="https://peopleofcolorintech.com/uncategorized/the-top-5-lessons-ive-learned-as-a-latina-in-tech/">The Top 5 Lessons I’ve Learned as a Latina in Tech</a></li><li><a href="https://hbr.org/2021/03/what-its-like-to-be-a-black-man-in-tech?ab=ascendhero-article-4">What It’s Like to Be a Black Man in Tech</a></li><li><a href="https://podcasts.apple.com/us/podcast/imposther/id1549282844">impostHER Podcast</a></li><li><a href="https://thenextweb.com/news/how-the-tech-industry-is-failing-people-with-disabilities-and-chronic-illnesses">How the tech industry is failing people with disabilities and chronic illnesses</a></li><li><a href="https://undevelopedbruce.com/2020/07/06/non-binary-in-tech/">How to be an ally to Non-binary folk in tech</a></li><li><a href="https://abcnews.go.com/Business/transgender-tech-visibility-obstacles-remain/story?id=76374628">Transgender in tech: More visibility but obstacles remain</a></li><li><a href="https://www.zdnet.com/article/transgender-employees-in-tech-why-this-progressive-industry-has-more-work-to-do-to-achieve-true-gender-inclusivity/">Transgender employees in tech: Why this “progressive” industry has more work to do to achieve true gender inclusivity</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=419c5cfc8779" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/cultivating-engineering-growth-419c5cfc8779">Cultivating Engineering Growth</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build Confidence in your Feature with a Test Fest]]></title>
            <link>https://engineering.gusto.com/build-confidence-in-your-feature-with-a-test-fest-d01ecc1b2622?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/d01ecc1b2622</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Tue, 13 Jul 2021 16:31:46 GMT</pubDate>
            <atom:updated>2024-06-25T19:13:38.126Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lr2glympgCJkfkSGGUecyA.jpeg" /></figure><p><strong>A step by step guide on successfully running a test fest</strong></p><p>The work is done, your team has spent the days, weeks, months, building a new feature and it is ready to deploy! But wait — will this new feature break everything?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jLd7rNfrK5BkJCbS.jpg" /></figure><p>Feature and unit tests can only go so far. The most certain way to find weak points in a new feature is through real users putting it to the test. It is amazing what real humans (especially non-engineers), who will sit down and click all the buttons, can find. This is where test fests can help.</p><h3>What is a test fest?</h3><p>A test fest happens whenever a group of people come together to test a new feature. The purpose of a test fest is to find bugs, unexplored edge cases, even incorrect copy or typos, before deploying to actual users. During a test fest, your feature and code are put through the ringer. Volunteer testers will attempt to find weak spots and edge cases that may have been missed during development.</p><h3>The invite list</h3><p>The invite list is determined by the scope and risk of a project. Ideally every test fest would include the engineers, designer, and product manager who worked on the feature. As a feature grows more complex, the test fest invite list should also grow.</p><p>Invite folks from customer-facing roles. This could include coworkers from sales, customer care, or user research roles. These groups are closest to the customer and have unique insight into how this feature will be utilized by actual users. Consider inviting people from teams who may not interact directly with the customer but who regularly dive into customer research, such as marketing.</p><p>Including engineers, designers, and product managers from other teams who work in tangential areas will provide a more well-rounded perspective to how the feature could be used in conjunction with the rest of the application. The test fest could be an excuse to introduce these other teams to the product change.</p><p>While having a cross functional team of testers can provide a more well-rounded perspective when testing, ultimately you are more likely to find unexpected bugs with more testers. When it comes to test fests, the more the merrier!</p><h3>Test fest doc</h3><p>Test fests are inherently messy. The testing team may not regularly work together. Testers may have varying levels of experience operating outside of production environments or thinking in terms of edge cases. A wide range of experience can make it difficult to provide instructions that work for all test fest attendees.</p><p>A test fest doc will help keep reign in the chaos, providing clear written instructions to the testing team.</p><p>Your test fest doc has three goals:</p><ol><li>Introduce the new feature</li><li>Instruct your testers on how to proceed</li><li>Document bugs</li></ol><p>Testers should be able to read a test fest doc and understand what the new feature does, how to start testing, and how to document any bugs they find.</p><h4>Introduce the feature</h4><p>Start with an overview of the feature to be released. Include any planning documents created by the team in preparation for this release, especially designs. The team’s original planning documentation can provide context to more curious testers, and spark ideas of additional areas to stress test.</p><p>It can be tempting for the over-prepared to write down a detailed list of all the ways a tester could interact with the new feature. Do not do this — less is more here. A test fest is meant to bring a wide variety of users to the feature, especially people who do not understand how the product should work. Provide too much instruction and testers may follow the directions exactly. We want testers who will stray from the <a href="https://en.wikipedia.org/wiki/Happy_path">happy path</a>, using the feature as they would naturally, leading to undiscovered edge cases.</p><p>The goal here is to provide just enough instruction to get testers started while remaining vague enough to allow people to explore the feature on their own. One method for providing helpful, but vague, guidance is to replace strict directions with open ended questions. Here are some examples of transitioning from direct instructions to helpful guidance.</p><ul><li>Use this feature as an accountant ➡ What if you tried using this feature as a different type of user?</li><li>Log in as an internal administrator ➡ How would our internal administrators monitor this feature?</li><li>Go to the dashboard then route to the billing page from the left-hand navigation bar ➡ Try approaching this feature from a different page.</li></ul><h4>Instructions</h4><p>Start with the basics. Remember that not everyone has attended a test fest before. Include a short description of test fests at the top of the test fest doc for the new testers. Even for the experienced tester, it is helpful to remind the team that <strong><em>the goal of a test fest is to break things</em></strong>. Break things now so they will not break later for real life users. Set this precedent at the top of the test fest doc. Remind testers to click all the buttons, think outside the box, try to find ways to stress test this feature the team may have missed.</p><p>More than one test fest has been derailed because the organizer did not provide clear instructions on how to access a staging environment and navigate to the feature in question. This seems like a simple step, but can be surprisingly complex. Some questions to ask when setting up instructions are do my testers:</p><ol><li>Have access to our staging environment?</li><li>Need to create an account? Do I have clear documentation on how to do this?</li><li>Know how to reach my new feature?</li></ol><h4>Bug Tracking</h4><p>The final, and most important, section of a test fest doc provides a way to document bugs found during testing. The goal of bug reporting is to make it easy for engineers to duplicate and fix any discovered problems after the test fest is complete.</p><p>Testers should report bugs they find directly in the test fest doc. Encourage details, screenshots, even screen recordings. At the start of a test fest this section should be incredibly short. Include an example bug to help testers get started.</p><p><strong>Example</strong></p><ul><li>[Name] Summary of what went wrong</li><li>Steps to reproduce</li></ul><ol><li>I went to this page</li><li>Clicked this button</li><li>Saw this thing</li></ol><ul><li>What was expected vs. what happened</li></ul><ol><li>Be detailed — could you repeat the bug? Does it happen for similar components?</li><li>Include photos or video</li></ol><h3>Prep</h3><p>Once the test fest doc is prepared, ask a coworker to try it out. Have this volunteer follow the document instructions, as a tester would, and ensure all critical steps are covered. If the testing team will include non-engineers, ensure this volunteer is, likewise, not an engineer. Engineers have expanded access to test environments and administrative permissions. Asking a non-engineer to try out your instructions will ensure that all testers can reach the proper staging environment and interact with the feature.</p><h3>Timing and scheduling</h3><p>When it comes to planning a test fest, the earlier the better. Stating the obvious, larger releases are more challenging to test than smaller releases. The more things there are to test, the less likely it is that your testers will be able to cover all edge cases. Testing in smaller batches means more focused testing, and therefore increased bug discovery.</p><p>Whenever you get the test fest on the calendar, <strong><em>do not forget to leave time to fix bugs discovered during the test fest</em></strong>. If your product needs to be deployed on Monday, do not schedule the test fest for a Friday. If this is the first time the product is in front of users, other than the engineering team, bugs will be found. Do yourself and your team a favor and plan for plenty of time to fix bugs during the work week.</p><h3>Party time</h3><p>Running a test fest can be stressful. I have planned several test fests where I spent an intense hour answering questions, digging into newly discovered bugs, and both worrying that testers would miss bugs <em>and</em> that they would find too many bugs. As the organizer, prepare for an intense hour of questions!</p><p>Remember the goal of the test fest is to <em>find</em> bugs, not to fix them during the meeting. Refrain from diving too far into code during a test fest and spend this designated time working with the team of testers. If a bug is found, document it and move on.</p><p>Releasing a new feature can be downright terrifying. Test fests allow teams a way to stress test their code with actual humans before it is deployed to users. Do you have any test fest tips or stories? Share them in the comments below!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d01ecc1b2622" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/build-confidence-in-your-feature-with-a-test-fest-d01ecc1b2622">Build Confidence in your Feature with a Test Fest</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build What Matters, Part 2]]></title>
            <link>https://engineering.gusto.com/build-what-matters-part-2-d8bd789f5716?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8bd789f5716</guid>
            <category><![CDATA[tidying-up]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[hardcoding]]></category>
            <category><![CDATA[experiment]]></category>
            <category><![CDATA[outcomes]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Fri, 23 Oct 2020 15:46:15 GMT</pubDate>
            <atom:updated>2024-06-25T19:16:06.154Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Hardcoded experiment to full-featured product</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4DKZFTpvQ3x76vkv.png" /></figure><p>I am part of the Partners Engineering team at Gusto, building our product for accountants and bookkeepers. Our team recently decided we could do more to work on experiment-based projects — putting out new features quickly and iterating on them based on customer feedback. We wanted to work on projects defined by outcomes.</p><p>In <a href="https://medium.com/gusto-engineering/build-what-matters-1cfd1e6d886d">part one of this series</a>, we discussed how to identify an outcome-based experiment and define a realistic <a href="https://medium.com/the-happy-startup-school/beyond-mvp-10-steps-to-make-your-product-minimum-loveable-51800164ae0c">minimum lovable product (MLP)</a>. In this final part of the series, we will take a closer look at how to actually bring an experiment to life as a full-fledged feature. If you think the hard work is complete once the project is defined, think again! Scope creep is a real and constant danger. Deciding how to iterate on an initial experiment can be easy — if you have the right data. Finally, there is some clean up to do! Fast experimentation can be messy and a responsible engineer should always strive to leave their code in a tidy state.</p><h3>Start with hardcoding</h3><p>My coworker <a href="https://medium.com/u/9e4da8e49d9e">Alyssa Hester</a> and I were going to build a way to recommend our trusted accountant partners to Gusto small businesses. We wanted to create custom recommendations between these two parties based on their common characteristics.</p><p>However, we needed to keep in mind, the goal of this experiment was to determine if we should move forward with building a recommendation engine. An ideal experiment would test a hypothesis with the minimum possible resources. This meant using a tool that is typically <em>extremely</em> frowned upon in a production environment — hardcoding.</p><p>This experiment would be heavily hardcoded and purposefully not scalable. We would launch it to a select group of small businesses. For each of these small businesses, our data science team would use an algorithm to manually generate a recommended accountant partner. This was a starting point from which we could determine if it was worth the engineer time to build out a full-featured recommendation engine.</p><p>With our hardcoded MLP, it was time to get to work and start building. However, as soon as we dove into the project we started to come up with new ideas that could potentially improve our outcomes.</p><h3>“No” is my new favorite word</h3><p>Throughout the project, our team came up with many wonderful ideas that would have undoubtedly increased the success of the project. There was only one problem — we didn’t have time to implement any of them.</p><p>Every time we encountered a new idea that would improve our success, we needed to make a decision on whether to make time for a potential additional feature. To decide we asked ourselves, “Is there an easier way to do this while still bringing value to the customer? Do we need this new feature to understand if customers will use the project?”</p><p>Some great ideas that we had to say “no” to:</p><p><strong>Idea: </strong>Providing more than one recommendation to the accounting firm<br><strong>Instead: </strong>We referred companies to our <a href="https://gusto.com/partners/directory">Partner Directory</a></p><p><strong>Idea: </strong>Providing detailed data on any connections made to our sales team via Salesforce<br><strong>Instead: </strong>CC’d our sales team on the initial email sent when making a connection between a company and a Partner</p><p>Just because a realistic MLP has been defined does not mean the project is in the clear. Scope creep is a real danger that should be fought at all times. The ultimate goal of the project should be kept in sight — building a feature that would increase accountant client adds.</p><h3>Collect all the data</h3><p>The point of this experiment was to determine if we should invest in a full-featured recommendation engine. Experiments mean data. All of this work would have been pointless without collecting the necessary data to determine if future investment was worthwhile.</p><p>We tracked every possible data point — views, clicks, connections. Anything that could be measured was measured. From this data we created a dashboard with all relevant information. It was this crucial information that allowed us to iterate on the experiment.</p><h3>Iterate on the experiment</h3><p>We launched our hardcoded experiment with a few days to spare. We sat back and waited for the results to roll in, tracking view and click through rates for companies viewing their recommended accounting firms. After a few months we determined that small businesses were very interested in viewing their custom recommendation for an accounting firm. However, based on performance data, the placement of our prompt to view this recommendation and the flow for connecting with the recommended accountant could be improved.</p><p>We took these learnings and launched a second experiment, placing the recommendation prompt in a new location with an increased number of custom recommendations. It only took us a few days to build upon the existing experiment. With round two, the interest rate in recommendations improved further. After two rounds of experimentation and positive feedback from both small businesses and Gusto Partners, we decided it was worth the effort to build a fully scalable recommendation engine.</p><p>We learned enough from each experiment to justify continued investment. After the second iteration, we decided it was time to create our full-fledged recommendation engine. Building the recommendation engine took significantly less effort than it would have without experimentation, as we were able to build on existing iterations. We are still waiting for data to bake on our recommendation engine in order to determine if we achieved the goals from our defined outcomes. In any case, we are regularly connecting small businesses on Gusto with our accountant partners, and initial results are promising.</p><h3>Clean up</h3><p>Engineers may be asking, with all this focus on outcomes and fast delivery, was there any impact to code quality? The answer is a hard yes. We purposefully decided to include non-scalable code into our codebase since this allowed us to build within the given timeline. While this was a necessary sacrifice, it certainly was not something I would want a coworker to git blame and attribute to my name a year from now.</p><p>As an engineer, you are responsible for the cleanliness of your codebase. I would not consider this project complete until we cleaned up unused code after the experiment was turned off. After building the full-featured recommendation engine, Alyssa and I deleted unused code and ensured we left our codebase in <a href="https://medium.com/gusto-engineering/does-this-code-spark-joy-23b1d7706bc0">a tidy state</a>.</p><h3>Keep going with outcome-based experiments</h3><p>After going through two experiments and finally launching the full-featured recommendation engine, we are happy with the outcomes through this process.</p><p>We spent minimal engineering, product, and design time shipping a minimum lovable product within only six weeks. Once the MLP was launched our customers in the experiment were able to benefit from these accounting firm recommendations within six weeks, instead of months. As an engineering team, we then iterated based on real customer feedback and data collected from our users. Finally, once we had gone through two experiment iterations, we were able to use what we learned and some existing code to speed up development of our full-featured recommendation engine.</p><p>While we are still tracking final metrics for outcomes from our recommendation engine, the early signs are promising. Overall, this outcome-based experiment allowed us to help both our accountant partners and our small businesses. Our team hopes to run many more of these experiments in the future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8bd789f5716" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/build-what-matters-part-2-d8bd789f5716">Build What Matters, Part 2</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build What Matters]]></title>
            <link>https://engineering.gusto.com/build-what-matters-1cfd1e6d886d?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cfd1e6d886d</guid>
            <category><![CDATA[outcomes]]></category>
            <category><![CDATA[experiment]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[perfectionism]]></category>
            <category><![CDATA[mvp]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Thu, 24 Sep 2020 17:31:43 GMT</pubDate>
            <atom:updated>2024-06-25T19:15:18.063Z</atom:updated>
            <content:encoded><![CDATA[<p>Defining an outcome-driven experiment</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bVi-3x13Oi2lTOzl.jpg" /></figure><p>At Gusto, Engineering has an ongoing discussion about how to quickly ship meaningful features to our customers. I am part of the Partners Engineering team here, building our product for accountants and bookkeepers. As a team, we want to work on the right things for our customers. We want to feel confident that features will be impactful when building something new.</p><p>My team decided to take a look at our process. We broke down a typical feature planning timeline and found that we typically spent three to five months from start to finish. This is a significant amount of time to spend on a feature, especially when we are uncertain how it will be received by our users.</p><p>In an ideal world, my team would ship smaller features to users more quickly. Doing so would allow us to gather immediate real world user feedback and take smaller steps to correct our course of action. To move toward this ideal world, we wanted to experiment — particularly with delivering features that were built around outcome-based goals.</p><p>With this mentality, I embarked on a mission with fellow Gusto engineer <a href="https://medium.com/u/9e4da8e49d9e">Alyssa Hester</a> to find and complete an experiment solely focused on customer outcomes. In this first post of this series, we’ll talk about how Alyssa and I found an outcome-based experiment and defined a realistic minimum lovable product (MLP). In the second post, we’ll take a look at how we brought the experiment to life, building from a hardcoded feature to a fully scalable product.</p><h3>Focus on outcomes over output</h3><p>What do I mean when I say outcome-based experiment?</p><p><strong>Output is the stuff you build.</strong> For example, if a team creates a new reporting feature to generate bulk reports, then your team’s <strong><em>output</em></strong> is the reporting tool itself. This could include the designs, the code, and anything else the team produced as part of this new feature.</p><p>Outcomes sometimes grow from output, but they are an entirely separate concept. <strong>Outcomes are changes in metrics and customer behavior — basically how customers respond to what we build — these are your team’s true goals. </strong>We focus on this because it tells us if customers truly find value in what we build. For example, outcomes for a new reporting tool could include increased retention, an improvement in customer satisfaction score, or an influx of customer referrals. Is your team’s actual objective to create a reporting tool or to bring more customers to your platform? The true focus of our work should be <strong><em>outcomes</em></strong>.</p><p>The first step for our project was defining the desired outcomes. With our team’s mission in mind, to help accountants and bookkeepers who I will refer to as Gusto Partners, Alyssa and I decided our goal was to create a feature that would increase the number of clients our accountants add to Gusto. We wanted to find a project that would help both Gusto and our Partners grow. We started searching for a project based on this outcome, with the intention of defining more specific metrics once a project was selected.</p><h3>Learn about the customer</h3><p>The engineers on our team, myself included, wanted to have a more detailed understanding of our customer. To identify a project that would increase accountant client adds, we needed to understand what motivates accountants to add clients.</p><p>In order to gain a better understanding of our customer, we relied on our customer-facing teams. I shadowed both our customer support and sales teams that specialize in working with our accountants. I was blown away by the level of knowledge they retain about each of their clients. Each sales team member could recite, from memory, a wish list of potential features for each of their clients. This experience provided me with some amazing insight into our accountants’ interactions with Gusto.</p><h3>Pick an outcome-based project</h3><p>After learning more about the customer, we sat down to discuss potential projects. Several ideas were turned away for being too focused on output, instead of outcomes. Some ideas were based around outcomes, but not accountant-based outcomes.</p><p>Our Head of Accountants and API Engineering, <a href="https://medium.com/u/a97cce239c7d">Jeremy Thomas</a>, came up with the final project idea — building a way to connect small businesses on Gusto that don’t currently work with an accountant or bookkeeper with our Gusto Partners.</p><p>We have a large pool of trusted accounting firms who are always looking for new clients, and thankfully, Gusto is in a position to help them with that. At Gusto, we serve more than 100,000 business owners. From our research, we know that these businesses are 80% more likely to be in business in five years if they are working directly with an accountant.</p><p>By capitalizing on our ability to recommend these trusted accounting firms to small businesses who would benefit from their services, we can help both our small business customers and partners achieve their desired business outcomes — a win win! We decided to bridge the gap between the two parties with a recommendation engine that would generate custom accounting firm recommendations for our small business customers.</p><p>In terms of outcomes, our hypothesis was that:</p><ol><li>Bringing more clients to our Gusto Partners would benefit our Gusto small businesses.</li><li>Bringing more clients to our Gusto Partners would encourage them to bring more small business clients to Gusto.</li></ol><p>With a project directive in hand, it was time to get to work. As we started to dig in, it became clear that the scope of this project could grow much larger than the four weeks we had left. Design alone could take several weeks. Meanwhile, the list of potential features was growing larger every day. When evaluating new features, we believed many would improve the success of our project, but we almost never had the time to build them.</p><p>As a team, we needed to shift our mindset in order to launch an experiment within a reasonable timeframe. We needed to move away from thinking this experiment needed to be perfect before launch. <strong>We needed to throw away our perfection mentality.</strong></p><h3>Escaping our perfection mentality</h3><p>As Gusto has grown, so has the impact of every new feature we ship. New features are instantly available to users. Every Gusto engineer has immediate access to the new code merged into our mainline branch. With so many eyes on every new change, it is easy to believe that every update or code release needs to be perfect.</p><p>Having a perfection mentality means that a feature is not good enough until it is absolutely flawless. Here are a few things “perfection” could mean in software:</p><ul><li>Design that has been fully user-tested</li><li>Code that solves for every potential edge case</li><li>Software that is fully scalable</li><li>Buy-in for this new feature from every department</li></ul><p>At face value, these all seem like very valuable qualities to have in a project about to launch. Of course, designs that have been user tested <em>are</em> more likely to be successful. As software engineers, we want to solve for the edge cases. We want our code to be scalable. We want to ensure the work we are doing will not have any negative impact on other projects at the company.</p><p>However, these benefits come at a cost — an actual dollar value cost of time spent by our team and a lost benefit cost to our customers. Product managers, engineers, and designers are spending time perfecting these features when we could be launching a more simplified project and collecting quick feedback from real users. In other words, we could be extreme in shortening our iteration cycles. Users could be benefiting from a simplified version of this feature sooner, instead of waiting for something “perfect”.</p><p>With four weeks left to ship, we did <em>not</em> have time to fall into this perfectionist mindset. We needed to define a project that would benefit our customers <em>and </em>that we could realistically ship within the given timeframe.</p><h3>Defining the most basic MLP</h3><p>We brought on a designer, data scientist <a href="https://medium.com/u/db66cc6133d">Becca Carter</a>, and product managers <a href="https://medium.com/u/97e0666d0fe">ankita verma</a> and <a href="https://medium.com/u/b1e78f24f1a9">Nora Tucker</a> to help us draw up the simplest <a href="https://medium.com/the-happy-startup-school/beyond-mvp-10-steps-to-make-your-product-minimum-loveable-51800164ae0c">minimum lovable product (MLP)</a> possible.</p><p>This is what we abandoned along with our perfection mentality:</p><ul><li>Design that was tested by real users</li><li>Dynamically creating recommendations</li><li>A user-tested recommendation algorithm that would provide the “perfect” recommended accounting firm to each company</li><li>Any additional features</li><li>Buy-in from marketing, sales, and business departments before starting work</li></ul><p>With our focus on getting this feature out within a reasonable time frame, this is what defined our MLP:</p><ul><li>A design we sketched out on a whiteboard in one hour</li><li>A plan for the data science team to select several thousand small business owners for whom they could “manually” generate accounting firm recommendations</li><li>A recommendation algorithm based on our best-guess of what companies care about when looking for an accounting firm</li><li>NO additional features, just make the recommendation</li><li>A weekly project update via email to keep any interested parties up to date on our progress</li></ul><p>The point of this project was to determine if a recommendation engine could encourage Gusto Partners to bring more clients to our platform while also helping our Gusto businesses find accountants. We wanted to answer the question — should we continue to invest time in this feature? We decided to launch something heavily manual that would provide us with enough data to determine whether we should build a fully scalable recommendation engine.</p><h3>Get Started</h3><p>We finally had our project, and it was time to get to work! Alyssa and I were given six weeks to complete this initial experiment and we had already spent three of those weeks working to identify and define the project. Now that we had an MLP, we needed to start building. In the final part of this series, we will walk through the process of taking an experimental feature from MLP to a full-fledged product.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cfd1e6d886d" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/build-what-matters-1cfd1e6d886d">Build What Matters</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Chipping Away at a Monolith]]></title>
            <link>https://engineering.gusto.com/chipping-away-at-a-monolith-de93b28e555b?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/de93b28e555b</guid>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[monolith]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Wed, 22 Jul 2020 16:34:51 GMT</pubDate>
            <atom:updated>2024-06-25T19:13:44.766Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1ux_DsSrVsUOcp4V.png" /></figure><p>My team recently embarked on a journey toward unbundling our part of Gusto’s monolithic Ruby on Rails app.</p><p>A monolithic app is a single application that contains code across many domains. The boundaries are unclear. The domains are fuzzy. Typically, as a monolithic app grows, it becomes increasingly difficult for developers to make changes due to unexpected consequences. This is especially true for Ruby on Rails applications, as the ✨ Rails magic ✨ encourages side effects, indistinct domains, and generally <a href="https://en.wikipedia.org/wiki/Spaghetti_code">spaghetti code</a>.</p><p>Gusto has a monolith problem. This is a good problem! It means we have been lucky enough to grow, build new features for our customers, and expand our abilities. However, for software engineers it slows down the development process as the tangled code results in unexpected bugs or overcautious programming. To help solve this problem, Gusto decided it was time to start unbundling the monolith.</p><p>My team, Partners Engineering, builds the experience for accountants within Gusto. Our domain is so distinct from the rest of Gusto that there is potential to eventually separate entirely from the core Gusto app. We could build a separate app with its own entities, database, and API, communicating with the rest of Gusto but living separately from the monolith.</p><p>We embarked on this project with this vision in mind — a completely separated Partners app with clearly defined boundaries.</p><h3>Where to start</h3><h4>Understand your domain</h4><p>The first step in separating from a monolith is understanding your domain. My entire team was relatively new to Gusto, meaning we had a lot to learn about our own domain. If you’ve been with the codebase from the beginning, this might look different, but chances are there’s some interaction with another area of the code that you do not know as well.</p><p>For several months, my team met weekly to discuss <a href="https://en.wikipedia.org/wiki/Domain-driven_design">Domain-Driven Design</a> and how our domain fits into it. Spreading these discussions out over a larger period of time gave the team space to discover more in our codebase, read more about different architectures, and get input from other teams. Over the course of several weeks we began to see a clear picture of an ideal Partners domain.</p><h4>Start small</h4><p>Deciding where to start felt like a daunting task. There were a lot of directions we could go. Should we begin with something small or should we gravitate towards the area that could have the biggest impact? Should we tidy up our code first or jump right in to defining boundaries between Partners and external groups?</p><p>I was tasked with finding a starting point for my team. I started by creating a list of models that belong in the Partners domain. I was searching for a complex model that should undeniably reside within Partners. One model in particular rose to the top as core to our future domain — Accounting Firm. Accounting Firm is a key concept within our domain. It is heavily bundled with external domains, but not in a way that would be impossible to separate. It would be the perfect place to start unbundling and defining a Partners boundary.</p><p>With this new Accounting Firm focus, I dove into a deeper audit of the model. I paid particular attention to concerns, callbacks, relationships, and methods that tied Accounting Firm to another Gusto model — Company. Company is a <a href="https://en.wikipedia.org/wiki/God_object">god model</a> within Gusto. It belongs within the core Gusto domain as a model that Accounting Firm should never access directly.</p><p>The results of this in depth analysis of the Accounting Firm model were overwhelming. By just taking time to review one model I created several epics to clean up the model. However, we needed to focus on one, achievable area where we could make an improvement.</p><p>We decided to start by removing one method — accounting_firm.companies. This method was the perfect place to start because it:</p><ul><li>Reaches across multiple boundaries</li><li>Is a crucial method for accounting firm</li><li>Could be removed without help from external teams</li><li>Would help us start defining Partners domain boundaries</li></ul><h4>Tidy up</h4><p>While <a href="https://medium.com/gusto-engineering/does-this-code-spark-joy-23b1d7706bc0">tidying up</a> our code will not help us define domain boundaries, or unbundle the monolith, it can help us prepare to take these larger steps. It is an incredibly helpful practice that allows us to pave the way for bigger changes.</p><p>During my investigation of Accounting Firm, I found a questionable area of code. In it there was orphaned code. There were strange relationships that resulted in two sources of truth. There was a test factory that created inaccurate duplicate data.</p><blockquote><em>While untidy code is not directly related to unbundling, it makes the unbundling efforts more difficult.</em></blockquote><p>I started unbundling with this basic cleanup. I removed the orphaned code. I spent several days fixing the bug in our tests that created duplicate data. It was not possible to tidy everything, but I tidied as much as I could. This paved a clear path for us to begin truly unbundling.</p><h3>Problems you may encounter</h3><p>We wanted two minds on this unbundling problem. So, my teammate <a href="https://medium.com/u/e1abe1fd9081">Grex</a> and I decided to pair full time for two weeks. Armed with our ownership mentality and the ability to approve our work as a team, we jumped into our unbundling epic.</p><p>We encountered a few obstacles when tackling this unbundling project. When you are working within a system that is completely intertwined, without clear boundaries, it is impossible to predict every issue you will find. Here are a few of the stumbling blocks that Grex and I came across while working on this project.</p><h4>Crossing into other domains</h4><p>Our work frequently took us outside of our domain into other areas of our code — with and without clear code owners. We had to give ourselves permission to make decisions in these other domains. For example, we wanted to create a service to retrieve Companies. This service was generic enough that it could potentially be useful to other teams, especially teams working on similar unbundling projects. What should this service look like? Where should it go?</p><p>Without a clear owner of Company, we had to give ourselves permission to make the best decisions with the knowledge we had. Without the power to make these fast decisions, our project might have taken six weeks instead of two. Besides, we could always make changes later!</p><h4>Shaving the yak</h4><p>When almost everything you see could be improved, how do you stay focused on the task at hand? Our team lead Matt calls this “ <a href="https://americanexpress.io/yak-shaving/">shaving the yak</a> “ — also known as going down a rabbit hole.</p><p>For example, Grex and I encountered many examples of the reverse method company.accounting_firm, which is also on our unbundling chopping block. We could potentially reuse some of the use cases we built for this purpose. Would it hurt to knock a few out while we were working on this anyway?</p><p>Yes, yes it would. This distraction would surely have led us to further distractions. When unbundling, it is important to have a clear goal in mind and stick with that goal even if other opportunities for unbundling arise. Instead of becoming distracted, we wrote down ideas for areas to return to later and continued on our mission to eliminate accounting_firm.companies.</p><h4>Unbundling tests</h4><p>When estimating unbundling time, do not forget about tests. Many of our tests utilized accounting_firm.companies. Some of our tests even stubbed out this method to control what was returned. Once we removed the companies method, these tests started to fail.</p><p>Fixing the tests took us a surprising amount of time, at least 50% of our pairing over the two weeks.</p><blockquote><em>Do not assume unbundling tests will be a fast process — it will probably take some time.</em></blockquote><h4>Fear of breaking things</h4><p>Two weeks and many planning sessions later, Grex and I had replaced all instances of accounting_firm.companies with ten new service classes. These new services did a variety of things, from simply returning the ids of companies related to the firm to returning filtered and refined company data. We were theoretically ready to remove this method entirely, cementing the new boundary we had drawn between Accounting Firm and Company. There was one problem - we were scared.</p><p>This had been such a crucial method, what if there were some uses that we had not caught with our text searches? Some critical function still using accounting_firm.companies that would cause some fatal bug that our tests did not catch?</p><p>We decided to remove #companies in baby steps. First, we added a comment deprecating the method. Second, we added some bug tracking to determine if anyone was indeed secretly using this method. After 24 hours without any reports, we felt confident that this method had truly been eliminated. We deleted accounting_firm.companies.</p><p>The harsh truth is, when unbundling there is a good chance you are going to break things. The best you can do is move slowly and cautiously, adding tests or logs where they were missing before to catch any bugs before they make it to production.</p><h3>What next?</h3><p>When you are working inside a monolith, unbundling can feel like an insurmountable task. This initial project was our first small step towards unbundling our domain. For the next several years, my team will likely be chipping away at our monolith. From this initial project, my team has created several epics and has an idea of where to move next. We have a better understanding of our domain and a little practice under our belt.</p><p>When it comes to unbundling, figuring out where to start can be the hardest part. Put in the work to understand your domain and codebase. Then just pick somewhere you think is useful, and get going. It is an impossible problem to solve all at once. Chipping away at the monolith bit by bit is how it will slowly become untangled.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de93b28e555b" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/chipping-away-at-a-monolith-de93b28e555b">Chipping Away at a Monolith</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Does this code spark joy?]]></title>
            <link>https://engineering.gusto.com/does-this-code-spark-joy-23b1d7706bc0?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/23b1d7706bc0</guid>
            <category><![CDATA[tidying-up]]></category>
            <category><![CDATA[tidying]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Mon, 09 Sep 2019 15:06:49 GMT</pubDate>
            <atom:updated>2024-06-25T19:18:37.594Z</atom:updated>
            <content:encoded><![CDATA[<h3>Tidying up your code bit by bit</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/0*Ya3XVvgRFV0lScUo.png" /></figure><p>Lifestyle experts want to bring simplicity to people’s lives through the magic of tidying up. People all over the world claim this method has brought happiness, and organization, to their cluttered lives. If only there was a Life-Changing Magic of Tidying Up for developers!</p><p>Whether you built or inherited it, most engineers have owned disorganized code at some point in their career. This messy code can result in bugs, prolonged development time, or increased difficulty with on-boarding new engineers.</p><p><strong>Tidying is the solution.</strong></p><p>Tidying does not mean a huge clean, spending hours upon hours working on a big mess all at once. Tidying means finding small areas of disorganization you improve by cleaning things up bit by bit. Tidying, in the context of code, results in purely structural changes to a confusing and messy section of code.</p><p><strong>The main motivation for tidying is a human one.</strong></p><p>As humans, <a href="https://www.scientificamerican.com/article/wired-for-categorization/">we like things to be organized</a>. We like carefully named functions and helper methods to break down complex problems into smaller, digestible pieces. Well organized code can be especially beneficial to engineers jumping into a new codebase or in preparation for a bigger refactor.</p><p>At Gusto, our resident tidying expert, <a href="https://medium.com/u/db2690bcb10e">Kent Beck</a>, has been encouraging engineers to start spending small amounts of time tidying up old code. I decided to give it a try, so I paired with Kent to tidy up our revenue share process. He walked me through some key strategies he takes while tidying up code; here they are, along with examples of how they changed our Gusto code.</p><h3>Tidying means structural (not behavioral) changes</h3><p>When tidying it is important to differentiate between structural and behavioral changes. Behavioral change means changing the way the code operates. Changing the return value of a function is an example of a behavioral change. Structural change, on the other hand, does not change how the code operates. Structural change rearranges and/or reorganizes the code. Separating functions into helper methods is an example of a structural change.</p><p>As we encountered during our pairing session, it can get a little tricky identifying behavioral vs structural changes. We looked at a function that creates PartnerRevenueSharePayouts from an invoice. Upon investigation, we found the return value of the method - partner_id - was not used anywhere except for tests. Not a good reason for a return value! We removed the call to partner_id at the end of this function.</p><p>At first glance, this update could be categorized as a behavioral change, however it was not an observable behavioral change. Therefore, it is a structural change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gLPQFdzDqfpf3cG5.png" /></figure><h3>Blank spaces are usually a good indicator for helper methods</h3><p>When tidying, we want to separate our code out into the smallest methods possible.</p><blockquote><em>Divide your program into methods that perform one identifiable task. Keep all of the operations in a method at the same level of abstraction. This will naturally result in programs with many small methods, each a few lines long. — Kent Beck</em></blockquote><p>We add blank spaces between blocks of code to separate sections that are accomplishing different tasks. Blank spaces are a great way to identify areas of code that can be separated into helper methods.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pfGz9f74V_hbNfGa.png" /></figure><p>Helper methods also give us the opportunity to communicate! Developers can define the purpose of their code through carefully named methods. Take the untidied code on the left. At first glance, you may be able to translate some of the code’s purpose — a payout is created if the partner is related to the given partner_id. With the tidied helper method solution on the right, that context is given for free. We are building partner revenue share payouts. The partner revenue share payout is created unless the revenue share is owned by the partner.</p><p>Helper methods not only keep things tidy, they help us communicate as well!</p><h3>Always keep tests green</h3><p>Tests should pass at <em>all</em> times when making changes. What does this actually mean for us as we code? <strong>Keep changes small</strong>. Re-run tests with every change. If you make a change and it does not work, do not keep pushing forward. Revert your change and try again.</p><p>Committing frequently, and only on green builds, will help keep your work organized. Purposefully named commits help keep track of changes. If you make a mistake, you can always revert to the last commit and find all green tests.</p><p>Failing tests are stressful. Remembering what you changed between the failing tests and the last passing tests is stressful (and difficult). The goal is to make things as stress-free and easy as possible. Small changes, frequent tests.</p><h3>If you cannot simplify, go for symmetry</h3><p>Sometimes it is not possible to pare things down with purely structural changes. For example, say you have two methods that accomplish similar tasks but use different records. It is not possible to refactor these methods into one without changing the behavior; however, you know there is potential to refactor in the future. When you encounter this situation, the goal is to make these similar methods as symmetrical as possible. The more identical the methods, the easier it will be to refactor into one method later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1_mNtk7RjX-iDhUq.png" /></figure><p>At first glance, the untidied code above appears to be creating revenue share payouts twice. Upon further investigation, Kent and I determined we are actually creating two different types of revenue share, payouts for accounting firms and payouts for software partners. This code is difficult to refactor. The BuildRevSharePayoutsService is a complex service with many different outcomes. Instead of attempting to refactor something this complex, we can break up these two completely different functions into purposefully named helper methods.</p><p>Now it is clear that we are creating two different types of revenue share payouts. By making these methods as symmetrical as possible, we make things easier to refactor for future engineers.</p><h3>Take breaks</h3><p>This is common programming advice, but I still find myself needing the reminder. Kent and I were stuck on a difficult problem for about 20 minutes while tidying together. After a 5-minute break, we regrouped and figured out the solution almost immediately. Do not waste time banging your head against the wall. Tidying up is tiring work and a little reset can clear things up.</p><h3>Go forth and tidy!</h3><p>Tidying is an easy way to tackle messy code. Before embarking on a large refactor, on-boarding new engineers, or simply for your own sanity, tidying up your code can help bring organization back to your working hours. Small steps towards a tidy codebase really add up.</p><p>Hopefully these tips and tricks I learned from Kent were helpful to you. Good luck on your tidying endeavors!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23b1d7706bc0" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/does-this-code-spark-joy-23b1d7706bc0">Does this code spark joy?</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Practical Guide to Building Secure SSO]]></title>
            <link>https://engineering.gusto.com/a-practical-guide-to-building-secure-sso-33c863a05b53?source=rss-3cc5c6024db0------2</link>
            <guid isPermaLink="false">https://medium.com/p/33c863a05b53</guid>
            <category><![CDATA[sso]]></category>
            <category><![CDATA[guides-and-tutorials]]></category>
            <category><![CDATA[oauth]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Tori Huang]]></dc:creator>
            <pubDate>Wed, 15 May 2019 20:26:00 GMT</pubDate>
            <atom:updated>2024-06-25T19:20:34.522Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*i6t1Gt6ZO35qlkLS.png" /></figure><p>Understanding how to build Single Sign On (SSO) using the OAuth 2.0 framework with OpenID Connect may seem like a daunting task, especially if this is your first time working with these tools. The internet is overflowing with information on the subject, but piecing everything together to form a working authorization system can be tricky.</p><p>My team encountered these difficulties first hand. As part of the Partners Engineering team at Gusto, I work to build an amazing experience for accountants, advisors, and other customers using Gusto to serve their clients. This includes ensuring a secure and easy way to connect with Gusto.</p><p>Working on SSO for Intuit was one of my first assignments as a new Gusto engineer. To learn more about authorization, I sifted through the multitude of OAuth 2.0 and OpenID Connect articles theoretically explaining what these tools were and found myself wishing there was one central location that walked me through exactly how to implement them.</p><p>This practical guide to the OAuth 2.0 framework, enhanced with OpenID Connect, will show you how to build a secure SSO system. We will take a step-by-step look at every request and response — starting with a high level overview of the process.</p><h3>What is SSO?</h3><p>With any SSO process there are three key players: the user, the relying party, and the identity provider. The user is the person requesting access. The account where she is requesting access is the relying party. The identify provider is the account she would like to identify herself with in order to create or access her account with the relying party.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IMPPE1UobD0rOPbtUq5sMg.png" /><figcaption>Login screen for gusto.com</figcaption></figure><p>While SSO does not necessarily need to start at the login screen, it is the most easily identifiable step in the process. The user here has an option to either log in to their Gusto account or use the SSO process to sign in via Google, Xero, or Intuit. Let’s look at an SSO example of a user named Melissa signing up with Gusto via her Intuit account.</p><p>The three key players:</p><ul><li>Melissa — the Gusto user trying to access Gusto</li><li>Gusto — the relying party where Melissa would like to gain access</li><li>Intuit — the identity provider Melissa wants to use to create a Gusto account</li></ul><p>Melissa wants to go to the Gusto homepage, click an Intuit sign in button, enter her Intuit credentials, and be redirected to her Gusto homepage. For this process to work, Gusto needs Intuit to share some of Melissa’s basic user information such as email, first name, and last name. However, Intuit cannot just hand over Melissa’s information to anyone who requests it. Intuit will need to carefully verify that the request is originating from Melissa and that Gusto is the relying party making this request for her.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-Mqm6o6AK4cNR2FK.png" /></figure><p>This is not a straightforward process! There is a great deal of back and forth between Melissa, Gusto, and Intuit. Let’s take a closer look at this process.</p><h3>Requesting a Code</h3><p>Gusto needs to request Melissa’s data from Intuit. The first step is receiving a code from Intuit, which we will eventually swap for a token. Here is what that request looks like.</p><pre>GET https://appcenter.intuit.com/connect/oauth2?client_id=your-client-id&amp;redirect_uri= https://app.gusto.com/user/auth/intuit/callback&amp;scope=openid%20profile email&amp;response_type=code&amp;state=auto-generated-state-field</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CIWPftAsV-50nQG61xOtDA.png" /></figure><p>Once we request a code from Intuit, Intuit must confirm Melissa’s identity and verify that she would like to give Gusto access to her Intuit account. This process typically looks like this:</p><ol><li>Intuit identifies Gusto by our client_id.</li><li>Intuit asks Melissa to login.</li><li>Intuit looks at the scope param requested with the code request. Scope specifies which data Gusto is asking for access to.</li><li>Intuit needs to determine if Gusto has access to the requested data (defined by the scope) for Melissa. Intuit will ask Melissa if she wants Gusto to access her data.</li></ol><h4>Do I have to use “code” for “response_type”?</h4><p>There are many response types to choose from when implementing the OAuth 2.0 framework. Authorization code grant is a common SSO response type. Authorization code grants are meant for web apps where the application is not the resource owner. In Melissa’s scenario where the resource owner is Intuit and the application is Gusto, an authorization code grant is appropriate. <a href="https://auth0.com/docs/api-auth/which-oauth-flow-to-use">Depending on your specific use case</a>, you may be better off with a different resource type.</p><h4><strong>Why can’t I request a token directly?</strong></h4><p>According to the OAuth 2.0 docs, “The authorization code provides a few important security benefits, such as the ability to authenticate the client, as well as the transmission of the access token directly to the client without passing it through the resource owner’s user-agent and potentially exposing it to others, including the resource owner.”</p><p>Basically, without requesting a code first the relying party cannot ensure that the requester is who they say they are.</p><h3>Returning the Code</h3><p>Once Intuit has verified Gusto can receive Melissa’s information, Intuit will send Gusto a code via a GET request to the redirect_uri defined in the Code Request params.</p><pre>GET https://gusto.com/user/auth/intuit/callback?state=&lt;state-field-from-gusto&gt;&amp;code=&lt;code-from-intuit&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-y721lgrdI8ikWNU8t7y-Q.png" /></figure><h4>State</h4><p>One of the major updates in OAuth 2.0 is the addition of a state parameter, which addresses a dangerous security gap in OAuth 1.0. <a href="https://auth0.com/docs/protocols/oauth2/oauth-state">The state parameter is defined by the requester and verified upon return of the code.</a></p><p>Step One is complete! Finally. Now we have a code and can exchange that code for Melissa’s token.</p><h3>Exchanging the Code for a Token</h3><p>We finally have our first response from Intuit! Gusto can now request an access token for the user through a POST request to the token url.</p><pre>POST https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer grant_type=authorization_code &amp;client_id=&lt;gustos-client-id&gt; &amp;client_secret=&lt;gustos-client-secret&gt; &amp;redirect_url=https://app.gusto.com/user/auth/intuit/callback &amp;code=&lt;code-provided-by-intuit&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*Awurtc8QCY_cZ4l_yabU4g.png" /></figure><p>If successful, this POST request will return a JWT token which can be used to access information about Melissa. JWT (JSON Web Tokens) is a standard that defines a compact way for <a href="https://jwt.io/introduction/">securely sending data as a JSON object</a>.</p><pre>HTTP/1.1 200<br>Content-Type: application/json<br>{<br>   &quot;access_token&quot;: &lt;jwt-access-token&gt;,<br>   &quot;expires_in&quot;: 3600,<br>   &quot;token_type&quot;: &quot;bearer&quot;,<br>   &quot;x_refresh_token_expires_in&quot;: 8726400,<br>   &quot;refresh_token&quot;: &lt;refresh-token&gt;,<br>   &quot;id_token&quot;: &lt;jwt-id-token&gt;<br>}</pre><h4>Validate the JWT Signature</h4><p>Congratulations — you have Melissa’s token! Your work is almost complete. Now we can decode the token and verify it using the public key. This public key is usually stored on the identity provider’s website. For example, Intuit’s public key is https://oauth.platform.intuit.com/op/v1/jwks. Intuit signed Melissa’s token with their private key. With Intuit’s public key we can use a JWT library to decode the token and verify its origin.</p><p>Public key structure is defined by <a href="https://developer.byu.edu/docs/consume-api/use-api/implement-openid-connect/jwks-public-key-documentation">OpenID Connect Standards</a>. The contents of the public key are defined by Intuit, so any user can access the public key and decipher JWT authorization data returned by Intuit.</p><h4>Finally Access Melissa’s Data</h4><p>Once deciphered, the JWT gives us access to Melissa’s Intuit user data. Gusto can take this data and use it to improve Melissa’s Gusto experience. In this case, we would store a record in Gusto’s database linking Melissa’s Intuit user ID to her Gusto user ID. The next time Melissa signs in to Gusto with Intuit, we will check our database for an existing mapping between her Intuit and Gusto accounts. When we find this mapping we can automatically log her in and redirect her to the Gusto dashboard.</p><pre>{<br>   &quot;sub&quot;: &lt;melissa-intuit-user-id&gt;,<br>   &quot;aud&quot;: [ &lt;aud&gt; ],<br>   &quot;auth_time&quot;: 1552063954,<br>   &quot;iss&quot;: &quot;https://oauth.platform.intuit.com/op/v1&quot;,<br>   &quot;exp&quot;: 1552067567,<br>   &quot;iat&quot;: 1552063967<br>}</pre><h3>Strategy Manager</h3><p>Authentication gets complicated. Utilizing a strategy manager can help standardize the process. Strategy managers can handle multiple authentication providers, making it easy for developers to connect with new identity providers.</p><h3>Pitfalls</h3><p>Once you finally retrieve the token, it may feel as though your work is complete. However, while some places will send user information within the JWT token, others require an additional request for user information. Be sure to carefully read through the docs in order to determine if this additional step is required for your specific authorization scenario. Your strategy manager should accommodate this additional step.</p><p>Another common pitfall is receiving an invalid_grant error when exchanging a code for a token. While this error seems unhelpful, it is probably telling you one of two things — your code has expired or the redirect url is invalid. In order to provide additional security, many identity providers will require the requester to define a list of acceptable redirect uris. If the redirect uri defined in the token request is not <strong><em>identical</em></strong> to the predefined acceptable redirect uri, you may receive an invalid_grant error.</p><h3>Resources</h3><p>Still confused? Walk through this process step by step with this <a href="https://openidconnect.net/">OpenID Connect Playground</a>. Another great resource for decoding JWT tokens is this <a href="https://jwt.io/">JWT Debugger</a>.</p><ul><li><a href="https://blog.runscope.com/posts/understanding-oauth-2-and-openid-connect">https://blog.runscope.com/posts/understanding-oauth-2-and-openid-connect</a></li><li><a href="https://auth0.com/docs/protocols/oauth2#how-response-type-works">https://auth0.com/docs/protocols/oauth2#how-response-type-works</a></li><li><a href="https://stackoverflow.com/questions/13387698/why-is-there-an-authorization-code-flow-in-oauth2-when-implicit-flow-works-s">https://stackoverflow.com/questions/13387698/why-is-there-an-authorization-code-flow-in-oauth2-when-implicit-flow-works-s</a></li></ul><p>Thank you to my coworker <a href="https://medium.com/u/979fb912f670">Julianna Roen</a> who walked me through this process and introduced me to these resources.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33c863a05b53" width="1" height="1" alt=""><hr><p><a href="https://engineering.gusto.com/a-practical-guide-to-building-secure-sso-33c863a05b53">A Practical Guide to Building Secure SSO</a> was originally published in <a href="https://engineering.gusto.com/">Gusto Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>