<?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 Kyle DeGuzman on Medium]]></title>
        <description><![CDATA[Stories by Kyle DeGuzman on Medium]]></description>
        <link>https://medium.com/@kyledeguzmanx?source=rss-cb80609ba9e7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6e-UUkDX59VKN2v3QyKraw.jpeg</url>
            <title>Stories by Kyle DeGuzman on Medium</title>
            <link>https://medium.com/@kyledeguzmanx?source=rss-cb80609ba9e7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 04:02:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kyledeguzmanx/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[A Personal Narrative: When I Felt Burnt Out]]></title>
            <link>https://medium.com/@kyledeguzmanx/a-personal-narrative-when-i-felt-burnt-out-71881f5b9c82?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/71881f5b9c82</guid>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Mon, 29 Dec 2025 17:26:59 GMT</pubDate>
            <atom:updated>2025-12-29T17:26:59.914Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Free preview from my new Substack </em><a href="https://therunbook.substack.com/p/a-personal-narrative-when-i-felt"><em>The Runbook by Kyle DeGuzman</em></a></p><p>At the end of 2022, as I reflected on what I wanted to achieve in the next calendar year, my goals were simple: ownership and impact.</p><p>I wanted to own a service end to end. I wanted to be the point person — the one people went to for answers. In 2023 and 2024, I got exactly that.</p><p>It was an exciting time to be me.</p><p>I worked directly with product managers and UX designers, with very little interference from my engineering team or my manager. Together, we built entire user journeys from scratch. For over a year, I decided what my schedule looked like and which parts of the product I would work on. I was trusted.</p><p>I came to work excited every day. There wasn’t an ounce of boredom, pressure, or burnout. Even debugging or writing integration tests felt satisfying. It sounds dorky, but I genuinely enjoyed the work.</p><p>At the same time, something very different was happening around me.</p><p>As our service moved closer to its general availability (GA) launch in 2024, leadership held frequent all-hands meetings to answer questions. Month after month, a common theme emerged: engineers across the organization were burnt out, overworked, and uninspired. Leadership kept pivoting strategy, even as launch approached, and those pivots demanded more work — often outside business hours.</p><p>People were vocal about it. Trust in leadership had eroded to the point where engineers were openly expressing their frustration during live Q&amp;A sessions.</p><p>I remember being surprised.</p><p>My service was isolated from most of the organization. I worked with separate packages, pipelines, and release processes. I rarely interacted with other teams. While the broader org was struggling, my experience felt insulated. I was fine — and if I’m being honest, I was fine staying fine, even if the system around me wasn’t working.</p><p>That changed in the middle of 2024.</p><p>Our leadership team restructured the organization constantly. Each restructure reflected a new set of milestones or goals they wanted to hit. Teams were reshuffled to maximize short-term delivery, and continuity became secondary.</p><p>During one of these planned restructures, I was told I’d be getting a new manager. My team would be split and absorbed by different teams.</p><p>To no one’s surprise, I was kept on the onboarding service. I had built and owned the front-end experience for onboarding. If there was one thing I was known for, it was that.</p><p>At the time, I took that as validation. After all the churn, keeping me on onboarding felt like a signal that leadership saw my value. I wasn’t easily replaceable.</p><p>Around the same time, my manager tried to push for my promotion before my new manager took over.</p><p>A month or two later, the promotion proposal was rejected.</p><p>What I learned was uncomfortable: I was valuable enough to keep exactly where I was, but not valuable enough to move forward.</p><p>They didn’t want to move me to new initiatives. They wanted me to stay put. My team was being split apart. I was getting a new manager. And the thing that would have made staying feel worthwhile — a promotion — was off the table.</p><p>It sucked.</p><p>As launch approached, the nature of the work changed. Feature development stopped. We shifted to bug fixes, security issues, and last-minute usability improvements. To me, the GA launch felt like the end of a chapter. I had done my part. I had built something substantial, and I was ready for a new challenge.</p><p>There were opportunities to move around within the organization, but I didn’t want them. Developer morale was awful, and I didn’t believe in the future of the product. Building something you don’t believe in is a uniquely draining experience.</p><p>Then came another reorganization.</p><p>I was placed onto a new team — one where I had to onboard all over again, learning a service I didn’t use, didn’t enjoy, and didn’t believe in. At the same time, my onboarding service was being handed off to a newly hired team.</p><p>Half my team was gone. My manager was gone. The work I was proud of was being transferred away.</p><p>That was the moment it became clear to me: this chapter was over.</p><p>Around November 2024, I started interviewing internally at Amazon. I knew I was going to leave. The burnout and distrust I felt made staying feel impossible. Still, I had confidence — maybe too much — that I’d find another opportunity.</p><p>In January 2025, I entered interview loops for what would become my current role at Amazon Music. Even with confidence, interviewing is nerve-wracking. I wanted this to work, and there were no guarantees.</p><p>At the same time, it was a new year, and work continued.</p><p>My new manager — my third manager in twelve months — wanted to help me get promoted. To demonstrate next-level impact, he immediately put me on a new feature. He asked me to onboard and produce a proposal within two weeks.</p><p>I didn’t believe in the product. I didn’t know the service. I didn’t use the app. And yet I was being asked to deeply understand it and design a feature that would justify a promotion.</p><p>I was burnt out.</p><p>I appreciated that my manager wanted to advocate for me, especially given how little time he’d known me. But I also felt insulted. A small, rushed feature proposal was being framed as the capstone to justify my promotion — after I had spent a year building dozens of features that culminated into an entire service.</p><p>The task itself was unrealistic. It lived at the intersection of front-end development and complex data models, requiring deep context to avoid breaking existing functionality. Two weeks wasn’t enough — not then, and not in hindsight.</p><p>Still, opting out wasn’t an option. If the interviews fell through, I’d be stuck.</p><p>So I did the work.</p><p>I struggled through onboarding, while juggling interviews. I stayed up late, trying to produce something — anything — worthy of review. A day or two before the presentation, I managed to pull together a proof of concept and a proposal outlining how the feature could be built properly.</p><p>The review was brutal.</p><p>Engineers who had worked on that part of the service for years asked valid questions — questions I simply didn’t have the context to answer, while they did. Sitting there, I felt exposed.</p><p>I felt stupid. Unprepared. Fraudulent.</p><p>It was jarring how the same organization that had made me feel on top of the world just months earlier could make me feel completely inadequate once I was removed from familiar context.</p><p>A few days later, my new manager was ready to send over the offer. He asked me to give my current manager a heads-up.</p><p>It was after 5 p.m. I called, heart racing, determined to keep the conversation short and professional.</p><p>I thanked him for his efforts around my promotion and told him I planned to move on. He was surprised. He said people usually leave after getting promoted, not before, and asked why.</p><p>At first, I said very little. Eventually, I explained: my service was being handed off, my team had been split, and I was being asked to onboard again. If I had to start over and confront unfamiliarity, I’d rather do it somewhere else.</p><p>He responded, “Okay. I’ll tell leadership you’re leaving because you didn’t get the promotion.”</p><p>I was stunned.</p><p>Not once had I mentioned promotion. But it was the explanation he chose to hear.</p><p>Later, he called again. After speaking with my new manager, he tried one last time to get me to stay — dangling the promise of promotion if I finished the feature first. It was framed as an opportunity, but it felt like self-preservation. The feature would take months, not weeks, and I wasn’t interested in the work.</p><p>I said no.</p><p>I was honest with my future manager as well. I told him I wasn’t equipped to finish the project and didn’t plan to.</p><p>Two weeks before my transfer, I was taken off all work. I closed out my time at AWS quietly, eventually heading to Los Angeles to start the next chapter.</p><p>I’m not proud of how that ending unfolded. At the time, I was stressed, demoralized, and disconnected. But it taught me something important.</p><p>I can’t work just for a paycheck.</p><p>My heart has to be in the work — or eventually, something breaks.</p><p>Nearly a year has passed since these events. I’ve explored multiple projects, deepening my skills in mobile development and UI design, and my manager has shown me that it’s okay to take time to learn. Unlike my previous organization, which made me feel limited in what I could develop, my new team has shown that growth is possible — and that being supported, with honesty about what’s realistic, makes all the difference.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*ju5EI2N4SzAdiPYa" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71881f5b9c82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building User Experiences: Lessons from my first 2 years at Amazon]]></title>
            <link>https://medium.com/@kyledeguzmanx/building-user-experiences-lessons-from-my-first-2-years-at-amazon-e6bb394b87b4?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6bb394b87b4</guid>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Mon, 01 Dec 2025 16:02:55 GMT</pubDate>
            <atom:updated>2025-12-01T16:02:55.220Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Free preview from my new Substack </em><a href="https://therunbook.substack.com/"><em>The Runbook by Kyle DeGuzman</em></a></p><p>After working on three services at Amazon, collaborating with industry veterans, and analyzing extensive user research, I’ve gathered some insights about creating user experiences. Here’s what I have learned.</p><h3>Good UX should be intuitive</h3><p>Engineers shouldn’t feel intimidated about voicing UX opinions just because they aren’t versed in the latest design trends. Building a good user experience fundamentally comes down to putting yourself in the customer’s shoes and ensuring the interface is self-explanatory.</p><p>As development team members, we’re incredibly close to our product. We know every nook and cranny because we built them. The challenge is stepping outside this mental model and viewing our screens with fresh eyes.</p><p>We should constantly ask ourselves: “If I wanted to perform a basic task — creating a project, deleting it, saving changes — what’s the most intuitive way to do that?”</p><p>While UX designers and product managers collaborate to build intuitive experiences, they too can have blind spots. Even UX experts can miss things — not due to lack of expertise, but because it’s impossible to perfectly predict how customers will use our products.</p><h3>The reality of intuitive design</h3><p>There’s no universal standard for good UX. It varies by service, use case, and target demographic. However, making your service intuitive often means analyzing your competitive space:</p><ul><li>What UX paradigms are your competitors using?</li><li>What patterns have become familiar to your target users?</li><li>How can you maintain familiarity while innovating?</li></ul><p>There’s a reason why music streaming services have similar layouts for top charts and albums. There’s a reason why services use the gear icon to represent settings. There’s a reason why social media platforms consistently offer likes, comments, and shares.</p><p>These established patterns create familiarity and drive adoption. However, this bring us to an interesting tension in UX design…</p><h3>Inventing new UX paradigms</h3><p>When building innovative services, I learned that creating new UX paradigms requires balancing novelty with familiarity. This is especially crucial when you’re entering an underserved market, simplifying complex workflows, and creating entirely new categories of products.</p><p>The challenge isn’t just innovation — it’s making that innovation accessible. Consider how tools like Photoshop or Unreal Engine make complex capabilities approachable:</p><ul><li>They use familiar metaphors (layers, tools, workspaces)</li><li>They provide multiple ways to accomplish tasks</li><li>They progressively disclose complexity</li></ul><p>In my experience, successful new paradigms:</p><ul><li>Build on existing mental models</li><li>Solve clear user problems</li><li>Minimize cognitive load</li><li>Maintain consistency within themselves</li></ul><p>And truthfully, you rarely get it right the first time. The only way to succeed in building good user experiences is through iteration. We must fail, learn, and improve our product based on customer feedback.</p><h3>Talk to your customers</h3><p>You should not just build a product and expect people to want it. Before building your product, you have to talk to your customers. What are their pain points? What does their workflow look like? What does their day-to-day look like? What tools are they currently using? What are their shortcomings?</p><p>You have to listen to what customers are telling you, but also listen for what they’re not telling you. Surprisingly often, customers have pain points they don’t even realize are pain points. From an outside perspective, you’re well-positioned to identify opportunities for optimization that customers might not see themselves.</p><p>While you should ask customers what solutions they’re looking for and what would make their workflows easier, take their suggestions with a grain of salt. Often, customers can’t conceptualize the most efficient solution to their problem. Your job is to understand their underlying needs, then design solutions that might not be obvious to them.</p><p>Your customers’ problems should inform both the problem you’re trying to solve and the UX you’re building.</p><p>After developing an MVP or prototype, give it to your customers. Ask them to perform specific tasks. They should be able to complete these tasks intuitively, just by looking at the screen, without your help. If they can’t, then improve, iterate, and repeat.</p><p>But customers aren’t your only source for determining the effectiveness and intuitiveness of your user experience.</p><h3>Analyzing business metrics</h3><p>When you build task flows, like creating a photo album or deleting an account, you should create business metrics (distinct from operational excellence metrics like latency).</p><p>Let’s look at an example: creating a photo album. The flow might look like:</p><ol><li>Customer clicks “Create Album” button.</li><li>Album creation page is opened.</li><li>Customer uploads pictures (via button or drag-and-drop).</li><li>Customer hits submit to create the album</li></ol><p>We need to track each step. How many customers clicked “Create album” button? If there is also a “Create album” option in the side navigation, which path do users prefer? Looking at the numbers, we might see:</p><ul><li>“Create Album” button clicks: 2000 interactions</li><li>Album creation page views: 1800 interactions</li><li>Photo upload attempts: 500 interactions</li><li>Album creation completion: 200 interactions</li></ul><p>This data tells a story, but interpreting that story isn’t always straightforward. Sometimes, especially with an abundance of data, patterns might appear to conflict. The key is to take the time to digest the information and consider all scenarios. When you analyze data thoughtfully, clarify often emerges from the complexity.</p><p>Using this data, we can</p><ul><li>Identify where users are dropping off</li><li>Investigate why the drop-offs occur</li><li>Test solutions to improve completion rates</li><li>Validate whether our UX changes are working</li></ul><h3>Iterating on our UX</h3><p>When you have dozens of customers complaining about the same issue, the path forward is clear — fix the problem. But when you’re using business metrics to understand drop-offs in a perfectly functional task flow, the solution isn’t always obvious. Often, you’re making educated guesses based on data patterns.</p><p>This is where iteration becomes essential. You make changes based on your best analysis and deploy to production. Then you monitor the metrics for several weeks to evaluate if the changes made a difference. If they didn’t, you iterate again with a different approach.</p><p>Many organizations also employ A/B testing. You show half your users one version of a task flow and the other half a different version. By comparing business metrics between the two groups, you can identify which approach drives better results.</p><h3>Driving adoption through multiple paths</h3><p>Customers bring learned behaviors from other applications to your product. When these familiar actions don’t produce expected results, your user experience must be clear enough to guide the customer to their goal.</p><p>Your job is minimize the friction. Beyond using familiar icons and terminology, services should provide multiple ways to accomplish tasks. Users naturally approach tasks differently. Some prefer clicking buttons, others use keyboard shortcuts, and some look for context menus. Building multiple paths to the same function isn’t redundant — it’s accommodative.</p><p>In some UX research interviews, customers are asked to perform a series of tasks without any help. By providing multiple paths to the same outcome, it would increase the likelihood that users will intuitively find their way. It makes the UX familiar and consistent.</p><h3>Consistency with design systems</h3><p>To build unified user experiences, enterprises create design systems and component libraries. It’s essentially a collection of patterns, color palettes, and reusable components that development teams can use to build user interfaces.</p><p>The idea is simple: all pages within a website or application should look and feel consistent, despite hundreds of engineers working on them.</p><p>These design systems, in my experience, are incredibly restrictive. They discourage teams from customizing component appearances or deviating from the usage and writing guidance.</p><p>Initially, I did not understand or agree with these limitations. At times, it felt like my service had many use cases that weren’t supported by the design system. But over time, I learned to appreciate the constraints.</p><p>Sometimes, multiple teams share ownership over a single page. If every team customized their user experience beyond the guidelines, it would create a wonky and disorienting customer experience.</p><h3>Final thoughts</h3><p>Building a good user experience is an iterative process. You have to use everything in your toolbelt — whether its your initial intuition, talking with your development team, talking to customers, or collecting business analytics to measure the effectiveness of your user experience. Then, you iterate. You increasingly make it easier for your customers to achieve their goals.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*EqUPpQZReGhmQMfa" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6bb394b87b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I’ve Interviewed for Amazon — Here’s What Most Candidates Overlook]]></title>
            <link>https://medium.com/@kyledeguzmanx/ive-interviewed-for-amazon-here-s-what-most-candidates-overlook-e71ba89ec96c?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e71ba89ec96c</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Mon, 24 Nov 2025 16:02:11 GMT</pubDate>
            <atom:updated>2025-12-01T00:01:17.094Z</atom:updated>
            <content:encoded><![CDATA[<h3>I’ve Interviewed for Amazon — Here’s What Most Candidates Overlook</h3><p><em>Free preview from my new Substack </em><a href="https://therunbook.substack.com/"><em>The Runbook by Kyle DeGuzman</em></a></p><p>Over the past two years, I have interviewed candidates for entry-level software engineering positions. Being on the other side of the hiring process has taught me that interviews aren’t just about answering questions or writing code; they’re about providing enough data points to convince interviewers that you’re qualified for the role.</p><h3><strong>Interviewers are collecting data points.</strong></h3><p>It’s not lost on candidates that we will ask behavioral questions related to Amazon’s leadership principles. Amazon’s preparation materials recommend the candidate prepare a few stories per principle. What may be overlooked is why we ask behavioral questions. Behavioral questions tied to Amazon’s leadership principles allow interviewers to gather evidence about how candidates embody these values in real-life scenarios.</p><p>In Amazon’s 2024 blog post, <em>I’m a recruiting manager at Amazon — here are 7 things I’d do differently if I could do my interview again</em>, marketing manager Brittany Bunch wrote, “We encourage you to see interviews as a way to provide data points about yourself, and the more data points the better.”</p><p>Candidates should enter interviews with the assumption that the interviewer knows nothing about them. The interviewer does not know their personality, their work ethic, their skills, or their accomplishments. It’s the responsibility of both the candidate and the interviewer to work together to unpack all of this throughout the interview.</p><p>Amazon’s interviews for SWE roles will be split into a behavioral portion and a technical portion.</p><p>In the behavioral portion, interviewers are trying to understand what challenges the candidate has faced and how the candidate has overcome them. The interviewer wants to understand situations where the candidate was a leader and how the candidate fits into the culture.</p><p>This is the time for candidates to showcase their achievements and provide detailed examples. It’s an opportunity to dive deep to maximize the amount of data points the interviewer has. A lot of times, my university candidates finish answering this question in maybe three minutes. If it ends too quickly, I won’t have enough data points to feel confident enough to endorse a decision to hire the candidate. We’ll circle back to this point in a bit.</p><p>While the behavioral portion focuses on past experiences, the technical portion tests your problem-solving and coding skills. For the technical portion, candidates should think out loud and walk the interviewer through the implementation. This also opens a door for dialogue. The interviewer can ask clarifying questions or offer suggestions, and it transforms into an opportunity to demonstrate your understanding of the problem and your approach to solving it.</p><p>While candidates should focus on providing as many data points as possible, it’s also important to understand the role the interviewer plays in shaping the experience — because not all interviewers are created equal.</p><h3><strong>Interviewers are not created equal.</strong></h3><p>Interviewers are human, and just like any other group of people, they come with different personalities. Some interviewers are friendly, encouraging, and engaged, making the experience feel like a collaborative conversation. However, there are those who are quiet, reserved, and speak only when spoken to — leaving the candidate feeling like they’re pulling teeth just to get through the interview.</p><p>The energy an interviewer brings can set the tone for the entire conversation. If the interviewer appears uninterested or disengaged, it can undermine a candidate’s confidence and make them hesitant to share their accomplishments and experiences.</p><p>My interviewing style, for example, is more conversational and relaxed. I prefer to dig deep into candidates’ experiences, often asking follow-up questions to encourage them to provide more detail. I’ve noticed that university candidates, in particular, often finish their answers in 2–3 minutes, leaving plenty of room for deeper exploration. In these cases, a bad interviewer might move on too soon, leaving the candidate with fewer data points to make their case. A good interviewer, on the other hand, will press further, seeking those crucial details that can make the difference in a hiring decision.</p><p>Occasionally, candidates may not fully answer the question or fail to provide a strong example in their initial response. In this case, a bad interviewer might move on without pressing for clarification. A good interviewer will keep asking questions until they’ve gathered the necessary information or until the time constraint forces them to move on.</p><p>While candidates can’t control how their interviewer behaves, they can control their approach. If a candidate understands that the interviewer is collecting data points to make a hiring decision, they should be proactive in offering those points. If the interviewer isn’t asking for deeper details, it’s up to the candidate to provide them. The goal is to give the interviewer as much information as possible to support a decision — without veering off-topic or losing focus.</p><h3><strong>Share new stories</strong></h3><p>In the previously referenced blog posts, manager Brittany Bunch wrote, “A common mistake we see is that candidates will repeat the same examples for each interviewer which results in a limited view into your strengths and experience.” This is particularly relevant for panel interviews. While it’s not a guaranteed opportunity-killer, it doesn’t help the candidate’s goal of maximizing the data points their interviewer can collect.</p><p>Interviews are essentially time-limited opportunities for interviewers to learn about the candidate. It’s crucial not to waste that time by sharing the same stories the hiring team has already heard. Instead, candidates should aim to offer fresh examples that showcase different aspects of their experience, demonstrating a broader range of strengths and skills.</p><h3><strong>Final thoughts</strong></h3><p>In the end, interviews are not just about answering questions — they’re about strategically sharing enough data points to support a hiring decision. By providing detailed examples, thinking out loud during technical interviews, and offering fresh stories throughout the process, you’ll give interviewers the full picture of your qualifications. Remember, the more data points you provide, the better equipped your interviewer will be to advocate for your candidacy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*EqUPpQZReGhmQMfa" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e71ba89ec96c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Technical Skill Isn’t Enough: What Engineers Miss About Building Products]]></title>
            <link>https://towardsdev.com/technical-skill-isnt-enough-what-engineers-miss-about-building-products-74a7591df467?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/74a7591df467</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Mon, 17 Nov 2025 16:02:28 GMT</pubDate>
            <atom:updated>2025-12-29T01:30:40.185Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Free preview from my new Substack </em><a href="https://therunbook.substack.com/p/technical-skill-isnt-enough-what"><em>The Runbook by Kyle DeGuzman</em></a></p><p>There are many successful cases of employees leaving major tech titans to pursue their own ventures. The YouTube founders were former PayPal employees; Anthropic’s founders came from OpenAI; and Instagram’s creators previously worked at Google. This pattern of big tech alumni launching successful startups continues unabated.</p><p>However, working on large-scale services for tech giants can give engineers a false sense of confidence. Building a service full-stack for a big tech company — which, in reality, isn’t always as extraordinary as it might seem from the outside — can lead to the mistaken conclusion that one can achieve the same results independently.</p><p>My network includes over 1,000 big tech employees, primarily entry-level and mid-level engineers. I’ve observed numerous passion projects and startups initiated by these engineers, and more often than not, I can predict when a service is unlikely to gain traction. This isn’t a reflection on the individuals’ capabilities, but rather on the viability of their ideas.</p><p>During my three-year tenure at Amazon, I’ve contributed to multiple private beta launches, a public preview launch, and a general availability (GA) launch. I’ve helped build entire services from the ground up and contributed to developing minimum viable products (MVPs). I’ve witnessed how our UX researchers engage with customers and have come to understand Amazon’s stringent criteria for what constitutes a good and viable idea. This experience allows me to readily identify the shortcomings in many startup ideas, whether it’s a lack of value proposition, unique differentiators, market demand, or other critical factors.</p><p>While these engineers may excel at implementing complex, large-scale systems for big tech companies — and even recreate sophisticated services using their own resources — the technical complexity of a service, no matter how impressive, doesn’t necessarily indicate product success.</p><p>In essence, a technically impressive and complex service without a clear value proposition is little more than a digital paperweight.</p><h3>The value proposition problem</h3><p>From the start, I consider three crucial questions:</p><ol><li>Are there existing services that occupy this space?</li><li>What makes this service different from competitors?</li><li>What prevents competitors from simply adding these differentiators to their products?</li></ol><p>A service will always have competition. Sometimes it’s direct and obvious, like Instagram Reels, TikTok, and YouTube Shorts competing in the short-form video space. Other times it’s broader, like TikTok and YouTube competing in the general video entertainment market.</p><p>What’s the unique value proposition that would drive customers to choose your service over competitors? I’ve seen engineers in my network create journaling and note-taking applications — with nothing proprietary about them. They’re just another app. You can’t have zero users, few App Store reviews — essentially no credibility — and lack proprietary features that elevate your service above the competition. Even with unique features, customers might overlook a lack of credibility out of necessity. But without any distinguishing factors, customers will naturally gravitate toward established services.</p><p>Let’s assume you do have proprietary features. What stops competitors from adding them to their existing services? Consider the many startups building on top of ChatGPT that offered specialized AI chatbots for specific industries — only to see OpenAI release custom GPTs. Or think about third-party iPad calculator apps that became irrelevant once Apple released their own calculator. Or social media scheduling tools that could become obsolete if platforms like Instagram simply add native scheduling features. When your entire business is essentially a feature that could be added to an existing platform, you’re building on borrowed time.</p><p>The moral: You need a unique value proposition that’s both difficult to replicate and independent of third-party services that could easily capture your customer base.</p><p>To be clear, “can’t be easily replicated” is more nuanced than it appears. Anyone could technically recreate Airbnb or Facebook today, but they wouldn’t gain traction. First-mover advantage and market saturation create natural barriers to replication. The market typically rejects copies when it’s already well-served by established players.</p><h3>The market reality check</h3><p>When peers build yet another journaling app, they often skip crucial market questions: Is this space underserved? Is there genuine demand for a new solution? If they considered these questions, they might invest their finite resources elsewhere.</p><p>Product development should start with identifying competitors’ blind spots — but not every gap deserves to be filled. Sometimes these gaps exist because established players have already determined they’re not worth pursuing.</p><p>Even with a product that fills a genuine market gap, demand alone doesn’t guarantee success. Your service can’t just exist — it needs discovery. This is where go-to-market strategy becomes critical, and I’ve learned these strategies vary significantly by market sector.</p><p>The distinction between consumer and enterprise applications is particularly striking. Having spent nearly three years in the enterprise sector, I’ve witnessed firsthand how much higher the barriers to entry are.</p><p>Consumer applications like Notion can leverage traditional marketing channels: Facebook ads, social media content, influencer partnerships, and television spots. Note-taking is a universal use case, relevant to most computer users. With simple authentication like “Sign in with Google,” users can quickly experience the product’s value. This low-friction approach helped fuel Notion’s growth, and as consumer adoption increased, enterprise customers followed.</p><p>Enterprise applications face a completely different reality. Facebook ads or influencer testimonials won’t sway corporate decision-makers. Without an existing customer base, you lack the credibility enterprises require. Security expectations are rigorous, and organizational adoption involves intense scrutiny. Perhaps most challenging: you need direct enterprise conversations — impossible without industry connections.</p><p>Even in the consumer space, visibility and credibility are crucial. I witnessed this firsthand with an Amazon colleague who built a front-end-to-backend development tool. After joining Y-Combinator, he approached visibility strategically: appearing on podcasts, speaking at conferences, and creating consistent content. He became the face of his service, building credibility across various developer communities. While the service ultimately didn’t succeed, his approach to visibility was exemplary — something rarely seen among my network of engineering founders.</p><p>Another thing this founder did right was recognizing he couldn’t do it alone.</p><h3>The One-Person Army Fallacy</h3><p>When I started my career, I didn’t grasp the value of product managers, UX designers, researchers, or technical writers. Seeing a dozen-person UX team seemed excessive. Wasn’t that overkill?</p><p>Curiosity led me to review their work — their research documentation, approaches, goals, customer interviews, and conclusions. UX researchers talk to customers — seemingly the simplest job in the world — but their findings reveal crucial insights that shape product development. This value becomes glaringly apparent when you work on projects without UX guidance. Similarly with product managers: entry-level engineers often dismiss PMs as unnecessary bureaucracy that stifles innovation. Yet work on a project without a PM, and their value becomes clear.</p><p>I’ve encountered projects and interfaces with atrocious copy and user flows. As the engineer who built the feature, it’s easy to miss these flaws — but to any outsider, they’re objectively terrible. Engineers excel at technical implementation but often struggle with user experience decisions. While a seasoned front-end engineer with a decade of experience might create decent interfaces, an organization of dozens of engineers with varying experience levels making independent UX decisions is a recipe for disaster.</p><p>Yet many of my peers building startups handle their mobile apps and websites alone — and it shows. Their demos and screenshots lack polish. A common pattern emerges: simple, boxy, poorly styled interfaces reminiscent of websites from 2007.</p><p>Beyond user interface and experience development, founders must address application security, marketing, and enterprise customer relationships. With a one-person team, it’s impossible to execute all these functions effectively.</p><h3>Final thoughts</h3><p>In Silicon Valley, you see many engineers who have worked on large-scale services for big tech companies — and they conclude their technical brilliance is enough to launch a successful startup. The truth is that it’s not enough. A successful startup relies more on an innovative, distinguishable, and valuable idea than technical expertise alone. It has to be an idea that is underserved and fills a gap that customers actually want solved. Beyond having a truly unique and innovative idea, you also need a dedicated team to carry out your vision. From building features and iterating the product to marketing and UX research, you cannot do it all yourself; maybe you can, but it won’t be of quality and it won’t be sustainable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*EqUPpQZReGhmQMfa" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74a7591df467" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/technical-skill-isnt-enough-what-engineers-miss-about-building-products-74a7591df467">Technical Skill Isn’t Enough: What Engineers Miss About Building Products</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Facebook Lets Billions of Users Decide Their Features]]></title>
            <link>https://medium.com/@kyledeguzmanx/how-facebook-lets-billions-of-users-decide-their-features-cc8423cbb9bb?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc8423cbb9bb</guid>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Wed, 09 Jul 2025 00:19:41 GMT</pubDate>
            <atom:updated>2025-12-01T00:02:05.779Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Free preview from my new Substack </em><a href="https://therunbook.substack.com/"><em>The Runbook by Kyle DeGuzman</em></a></p><p>Successful products are built by teams that listen to their customers. After all, how can you solve someone’s problems without understanding what those problems are? When you build without customer input, you’re investing time and money on hunches and assumptions. You’re essentially telling customers what their problems are, rather than letting them tell you. It’s presumptuous, and often leads to products that miss the mark.</p><p>There are different ways to listen to customers. At Amazon, where customer obsession is foundational to the culture, every innovation begins and ends with the customer. Ideas for new services, from Prime Two-Day Shipping to Amazon Bedrock, start with the customer. From ideation through development, the customer’s voice guides the way. Before launch, trusted partners beta test the product and shape its direction. Even after release, Amazon continues gathering feedback to evolve their products and prioritize new features.</p><p>Facebook takes a radically different approach. Instead of asking customers what they want, Facebook watches what they do. Through billions of data points from user interactions, they discover what their customers actually like, not just what they say they like. This isn’t traditional customer feedback; it’s data science at scale, powered by sophisticated A/B testing.</p><h3>What is A/B testing?</h3><p>When you develop software, you face countless implementation decisions. It’s plainly because there are a billion different ways you can implement something. While there are clearly wrong ways to build features, there’s rarely one “right” way. Take YouTube’s homepage, for example. We’re familiar with its carousel-style of video thumbnails, but that’s just one of countless ways to display video content. YouTube chose this approach, but why? How did they know it would work?</p><p>Software teams make these decisions through collaborative discussions. Engineers, product managers, and designers bring their expertise and experience to the table. They debate different approaches, consider trade-offs, and try to arrive at the best solution. But here’s the reality: even the most experienced teams can’t perfectly predict how users will respond to their choices. What worked for Instagram or Netflix might fall flat with your users.</p><p>This is where A/B testing may help. It’s experimentation, pure and simple. Instead of guessing what users want, you show different versions of a feature to different groups of users and measure their responses.</p><p>Consider a simple example: your team is designing a “create post” button. Should it say “Create,” “Create new post,” “Publish,” or just show a plus icon? Instead of debating endlessly, you can test all variants with real users.</p><p>Or take a more complex example: improving the onboarding experience. Say you’re building a social platform where users choose usernames. In the current onboarding experience, the customer must type a username, click submit, and find out if it’s available. We want to simplify this experience. One variant pre-fills the textfield with a combination of the customer’s first and last name. Another variant pre-fills the textfield with their email username. Another variant performs a live validation check to verify username availability. And then another variant adds a message to communicate usernames can be changed later to ease the customer’s anxiety for picking a username.</p><p>The development team monitors business metrics for each of the variants. Business metrics are essentially quantitative data regarding user behaviors and actions that a business actually cares about. For example, for sign up page, we might care about:</p><ul><li>how many views did the sign up page receive?</li><li>how many customers interacted with at least one of the form fields in the sign up page?</li><li>how many customers hit the submit button?</li><li>how many customers hit the submit button and hit error? For example, how many customers are seeing the error “username is already taken”? And after seeing that error, how many customers try again versus exit the page?</li></ul><p>By comparing these metrics across variants, like signup completion rates or time spent on the username step, teams can make data-driven decisions. Sometimes the data suggests moving forward with a specific variant of the new feature; sometimes it reveals the current version works best. Either way, you’re letting real user behavior, not opinions, guide the decision.</p><h3>Facebook’s scale of experimentation</h3><p>Facebook has masterfully built their product through A/B testing. They’ve built sophisticated systems to run thousands of experiments simultaneously. Their platform divides over a billion users into more than 10,000 segments, allowing software development teams to experiment with new features at a scale most companies can only dream of.</p><p>What makes Facebook fascinating is the sheer impact of their experiments. When you’re dealing with billions of users, even a small 5% change in engagement could mean millions of users. For Facebook, where user engagement and retention directly impacts their business, these seemingly small percentage changes represent massive real-world impact.</p><p>But with Facebook’s scale, they’re uniquely positioned to collect statistically significant data quickly. They can test features across different segments simultaneously, and they can quickly understand the impact of even the most subtle changes like changing a button color.</p><p>This is how Facebook truly lets their users decide their features. While most companies rely on customer interviews and feedback forms, Facebook has built a system where billions of users vote through their everyday actions. Every click, every interaction, and every minute spent on the platform helps shape Facebook into what it is today: a product defined not by what users say they want, but by what they actually use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*EqUPpQZReGhmQMfa" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc8423cbb9bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Experience: Finding Your Voice as a New Engineer]]></title>
            <link>https://medium.com/@kyledeguzmanx/beyond-experience-finding-your-voice-as-a-new-engineer-0c4a8bff9db6?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c4a8bff9db6</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[web-developer]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Fri, 04 Apr 2025 15:01:29 GMT</pubDate>
            <atom:updated>2025-12-01T00:02:30.249Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Free preview from my new Substack </em><a href="https://therunbook.substack.com/"><em>The Runbook by Kyle DeGuzman</em></a></p><p>For me, it’s never been about the notorious imposter syndrome. I’ve never felt like I didn’t deserve my place at Amazon because of any shortcomings. I’ve always understood that this was my first job, that three years in the workforce is relatively short, and that there’s industry and technical knowledge I’ll only gain through experience. As I’ve grown, I’ve found comfort knowing that learning never stops. Even senior engineers don’t know everything, and they’re comfortable admitting it.</p><p>But despite not struggling with imposter syndrome, I face a different challenge. With limited tenure and experience, I frequently find myself struggling to find my voice when working with more tenured engineers, product managers, and leadership.</p><h3>Understanding the Challenge</h3><p>I’ve repeatedly found myself in situations where I felt I lacked the authority to argue for what I believed was the right path forward. This hesitation stemmed from various sources: my relatively short tenure, my role as a front-end engineer, or simply a lack of context in certain areas.</p><p><strong>Product Decisions Without Context</strong></p><p>Working with product managers and UX designers on user interfaces, I occasionally found myself disagreeing with their approaches. Where I advocated for following AWS guidance, maintaining transparency, and giving customers choice, product managers often pushed for solutions that went against these principles. They wanted to deviate from established AWS paradigms and simplify flows by removing customer options. When faced with these more tenured product managers, and knowing their approaches wouldn’t cause immediate technical issues, I often conceded. The irony? After launch and customer feedback, many of our “fixes” ended up restoring the very features and patterns I had initially proposed.</p><p><strong>Technical Decisions Without Authority</strong></p><p>While working on a backend service, I encountered practices that went against type safety principles. Where I advocated for explicit error checking and defensive programming, the team preferred to trust their assumptions that certain values would always be present. Their experience told them these additional checks were unnecessary — after all, why verify something that should always exist?</p><p>As we scaled our service to support new regions and added new features, this confidence proved costly. When issues arose, debugging became unnecessarily complex because we couldn’t easily trace where our assumptions had failed. Even when mentoring junior engineers, I found myself caught between teaching best practices and conforming to the team’s established patterns. Engineers would question why we needed “extra” safety checks, but time and experience would later validate my more cautious approach.</p><p><strong>Growth Through Experience</strong></p><p>The challenge extended beyond code. In discussions for introducing new features in services I didn’t work with — like authentication, authorization, or other backend services — I found it difficult to contribute to the conversation. I had no knowledge, experience, or expertise to draw from. Now, after spending time working with various AWS services — such as AWS Lambda, CloudFront, IAM Identity Center, CodeCatalyst, and StepFunctions — I can engage in these conversations more confidently.</p><p>This journey taught me an important lesson about voice and experience. While I respected my colleagues’ tenure and experience — most had been at Amazon for 3+ years with prior industry experience — I learned that seniority alone doesn’t guarantee the best solutions. The stakes weren’t as low as I thought, and being proven right later was both validating and instructive: technical discourse shouldn’t be about tenure, but about merit.</p><h3>The Power of Self-Awareness</h3><p>In the past year, I’ve been encouraged by my managers to amplify my voice as it’s a requirement for promotion. This push planted seeds of self-doubt until I realized something important: my hesitation to contribute doesn’t come from feeling incapable — it comes from inexperience and lacking context.</p><p>With nearly three years in tech, I’ve learned to be comfortable with my knowledge gaps. As the only front-end engineer on my team for a year, I was somehow expected to magically acquire knowledge about backend services I never touched. When moved to a new team, I was expected to meaningfully contribute within a week. While other engineers faced similar knowledge gaps, the spotlight was on me because of promotion expectations.</p><p>This pressure helped me understand something crucial: being aware of your knowledge gaps isn’t a weakness — it’s professional maturity.</p><h3>Final thoughts</h3><p>Finding your voice as a newer engineer is a complex challenge.</p><p>In situations where you actually know what you’re talking about, it can be daunting to voice concerns and disagree with more tenured peers. You can’t help but wonder if their experience offers insights you just don’t have yet. And there’s a significant difference between momentarily disagreeing and having the courage to engage in a constructive exchange. When you feel like you don’t have a leg to stand on, it’s easier to concede than to advocate for what you believe in — even if you might not win the dispute.</p><p>On the other hand, in situations where you lack context, it’s difficult to contribute meaningfully to discussions when you have no background knowledge or experience to draw from. It’s hard to find your voice when you genuinely have nothing to say. But recognizing this distinction — between lacking confidence and lacking context — is perhaps the first step in growing as an engineer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*EqUPpQZReGhmQMfa" /></figure><p><em>For new blog posts, you can check out my new substack </em><a href="https://therunbook.substack.com/"><em>The Runbook by Kyle DeGuzman</em></a></p><p><em>Find me on LinkedIn </em><a href="https://www.linkedin.com/in/kyledeguzmanx/"><em>https://www.linkedin.com/in/kyledeguzmanx/</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c4a8bff9db6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Approach Code Reviews as a Reviewee]]></title>
            <link>https://towardsdev.com/how-i-approach-code-reviews-as-a-reviewee-4cc48ca81277?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cc48ca81277</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Mon, 29 May 2023 18:56:13 GMT</pubDate>
            <atom:updated>2023-05-30T19:08:11.040Z</atom:updated>
            <content:encoded><![CDATA[<h4>Sharing Best Practices</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*R0qUbIpeik_aBlPP" /><figcaption>Photo by <a href="https://viarami.com/"><strong>Markus Winkler</strong></a></figcaption></figure><p>Before I joined Amazon, I hadn’t really experienced the formal code review process, which others might know as ‘pull requests’. During my time at university, I worked with three different development teams on various projects. When it came to putting our code into action and making it ‘production-ready,’ we took a less formal approach. Instead of doing peer reviews, we simply pushed our code into the mainline branch. Our main focus was on getting our own features done.</p><p>We didn’t really consider the readability, maintainability, and scalability of our code. Breaking down large files into components and separate pages wasn’t something we prioritized. Accessibility and security weren’t on our radar either. And let’s be honest, we didn’t give much thought to handling edge cases and errors.</p><p>Our main thought was straightforward: “If it works, it’s good enough.” That’s as far as we went in our thinking.</p><p>Looking back on my initial five months at Amazon, I now realize that I was struggling with my code reviews, even though I wasn’t fully aware of it at the time. I remember going through nearly six code revisions for each ticket I worked on. Every revision would inevitably bring many critical comments, which, to be honest, was not only fair but also valid. It was a somewhat embarrassing experience, to say the least.</p><p>On one hand, I must acknowledge that as a recent university hire, it was only natural for me to lack the immediate proficiency in writing production-level code. Learning such skills takes time and practice, and I was certainly in the process of acquiring them. However, on the other hand, whenever I received feedback asking for code adjustments, I couldn’t help but feel as though I was wasting my team’s valuable time. Why couldn’t I seem to get it right on the first attempt?</p><p>Today marks my official ten-month milestone in this journey. While I don’t consider myself an expert just yet, I have undoubtedly witnessed significant improvements in the quality of my code changes. I no longer find myself going through numerous revisions, and the feedback I receive generally focuses on smaller adjustments rather than major overhauls. With that in mind, I would like to share some valuable insights on what I now look for before finalizing and sharing a code review (CR). My hope is that these notes will help you bypass the mistakes I made along the way. So, without further ado, let’s dive in.</p><h3>First, let’s start with my bare-minimum checklist.</h3><p>These are the bare-minimum expectations that my team expects. If any of these are missing, it will definitely not get approved. <em>It’s important to note that your own teams may have different expectations.</em></p><h3>Unit Tests</h3><p>First and foremost, it is crucial to verify that your code changes haven’t introduced any issues to the existing features. All existing unit tests should pass without any failures. If any tests do fail, it’s essential to debug and rectify the problems. It’s worth noting that when introducing new features, it may be necessary to modify existing unit tests to accommodate the changes. Adapt accordingly.</p><p>Secondly, it’s always recommended to write unit tests that ensure your code performs as intended. These tests serve as evidence that your code functions correctly at present and will continue to do so as more features are added to the service. Take a close look at the lines of code you’ve added in the code review (CR) and strive to provide test coverage for all of them. Your tests should be clear, readable, and well-organized. While there might be some lines that cannot be tested due to technical constraints, aim to cover as much as possible in your testing efforts.</p><p>To learn more about testing, I recommend going through the <a href="https://jestjs.io/docs/expect">Jest Documentation</a>. And to learn about code coverage reports, I will recommend <a href="https://medium.com/steve-cruz/awesome-jest-tip-coverage-report-6f1e303ef07">Awesome Jest Tip: Coverage Report</a>.</p><h3>Linters and Formatters</h3><p>It is important to make sure that your code undergoes proper linting and formatting. Take the time to make sure that all your code is correctly indented and spaced. Add necessary commas and curly braces in their expected places.</p><p>If your team utilizes TypeScript, as mine does, it is essential to check for any TypeErrors and ensure that the types are appropriately defined and utilized.</p><p>Here are some VS Code Extensions I use:</p><ol><li><a href="https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint">ES LINT</a> by Microsoft</li><li><a href="https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode">Prettier — Code formatter</a></li></ol><h3>Next, let’s find lines that can get clocked</h3><p>In the following phase, I meticulously review my code additions line by line, searching for any potential areas of criticism. If there are flaws, what specific aspects would be pointed out? This phase can be challenging because if there were inherent flaws, you wouldn’t have written the code that way in the first place. Nonetheless, do your best to adopt a critical mindset toward your work.</p><p>If you’ve had previous code reviews where you received feedback, take a moment to reflect on that input. Have you made the same mistakes again? Alternatively, if you have access to code reviews or pull requests (PRs) created by others, consider reviewing their comments. Learning from their mistakes can be highly beneficial. Additionally, exploring the repository might unveil recurring patterns and coding conventions that you can adopt.</p><p>If you find yourself having made extensive changes to the code, to the point where reviewing it line by line feels overwhelming, consider breaking down your tasks into multiple subtasks and splitting the code reviews into separate components. This approach can help streamline the process.</p><p>Now, let’s delve into some of the key aspects I prioritize during the code review process:</p><h4>Typos</h4><p>Make sure that everything is spelled correctly. Personally, I used to have a tendency to quickly skim through this aspect, assuming I had done it correctly. However, I have come to realize the importance of giving it proper attention. Recently, I have encountered a noticeable number of typos, prompting me to slow down and take my time with this step.</p><h4>Naming Conventions</h4><p>It is crucial to follow naming conventions within your team. If your team has documentation, make sure to review it to understand the recommended naming practices. In the absence of documentation, examine existing files to gain insights into how variables should be named.</p><p>Observe how variables are named in your team. For instance, in my team, boolean variables typically start with “is,” such as “isModalOpen,” “isLoading,” or “isDisabled.” We prioritize this convention, even if it may be grammatically incorrect. For example, we prefer “isFieldsDisabled” over “areFieldsDisabled.”</p><p>Abbreviations are discouraged in my team since they hinder readability. We prioritize using descriptive names, such as “numberOfPigs” instead of “noPigs,” “noOfPigs,” or “numPigs.” The goal is to ensure that both the current and future team members can easily understand the code at a glance.</p><p>When it comes to typing props for components and pages, we prefer using TypeScript’s interfaces. The convention we follow is to name the interface &lt;ComponentName&gt;Props. For example, if the component is called ExitModal, the corresponding interface for its props would be ExitModalProps.</p><p>We frequently utilize enums, and our convention is to use singular names for them. For example, we would use “Color” instead of “Colors.” The first letter of the enum name is capitalized, and we always provide explicit values for the enum members instead of relying on default values.</p><p>For handler functions, our team does not strictly follow a set convention. The primary criterion is readability. However, I have my own conventions for handler functions, which I follow because I know my team is comfortable with them. For instance, I prefix function names for handling events with “handle,” such as “handleOnChange.”</p><p>For function props passed to components, the names always start with “on.” For example, “onClick,” “onChange,” or “onRequestClose” are commonly used.</p><p>When creating callback functions for a single child component, using “handleOnChange” would be sufficient. For example:</p><pre>const handleOnChange = useCallback(() =&gt; {}, []);<br>return (<br>    &lt;TextField onChange={handleOnChange} /&gt;<br>);</pre><p>However, if you are creating callback functions for multiple child components, it is recommended to differentiate them with the component name. For example:</p><pre>const handleNameOnChange = useCallback(() =&gt; {}, []);<br>const handleJobTitleOnChange = useCallback(() =&gt; {}, []);<br>return (<br>   &lt;&gt;<br>        &lt;TextField onChange={handleNameOnChange} /&gt;<br>        &lt;Dropdown onChange={handleJobTitleOnChange} /&gt;<br>   &lt;/&gt;<br>);</pre><p>Above all, prioritizing readability is of utmost importance. Take the time to review your own codebase and observe how your team names variables, adhering to the conventions followed within your team.</p><h4>Function Names</h4><p>Ensure that the purpose and behavior of a function are clear just by reading its name. A well-named function should provide enough information to understand its functionality without needing to refer to the function’s definition. Consider the following example:</p><pre>const address = getAddressFromName(&quot;Angela Bassett&quot;);</pre><h4>Repetition</h4><p>Avoid repeating the same hardcoded values throughout your code. Instead, assign such values to variables. By doing so, if the value needs to be changed in the future, you only need to modify the variable declaration.</p><p>Similarly, if you find yourself performing identical operations in multiple places within your codebase, consider creating a reusable function to encapsulate those operations.</p><p>In my own experience, particularly when I was new, there were instances where I would create a function that already existed in other packages owned by our team. We have packages containing utility functions that we import for use in our web app. If your team follows a similar practice, make sure to check if a similar function already exists within your team’s packages. Developing the skill to recognize the relevant packages may take time, especially for newcomers who might be unfamiliar with the team’s package ecosystem.</p><p>Additionally, our team relies on the popular lodash package, which offers a wide range of useful functions. Depending on the specific task you are working on, it may be worth checking lodash for any relevant functions that can simplify your code.</p><h4>Scalability</h4><p>Scalability is a crucial aspect of writing code. When we anticipate the need to add more elements or scale up our application, it’s important to ensure that the code changes remain easy to understand and maintain.</p><p>Consider the following example using an enum called Color:</p><pre>enum Color {<br>  Blue = &quot;blue&quot;,<br>  Brown = &quot;brown&quot;,<br>}<br><br>const x = &quot;Blue&quot;;<br><br>if (x === Color.Blue) {<br>  // Code block for Blue color<br>} else if (x === Color.Brown) {<br>  // Code block for Brown color<br>}</pre><p>If we were to introduce new colors, we would need to keep adding else if statements, which can lead to less readable and less maintainable code. To address this, it is recommended to use a switch statement.</p><pre>enum Color {<br>  Blue = &quot;blue&quot;,<br>  Brown = &quot;brown&quot;,<br>}<br><br>const isColor = (input: string) =&gt; {<br>  switch (input) {<br>    case Color.Blue:<br>      // Code block for Blue color<br>      break;<br>    case Color.Brown:<br>      // Code block for Brown color<br>      break;<br>    default:<br>      // Code block for unsupported colors<br>      break;<br>  }<br>};<br><br>function Component() {<br>  // Uses isColor function<br>}</pre><p>By encapsulating the switch statement in a separate function outside the scope of the React component, we improve readability and maintainability.</p><p>Another scenario involves checking if a value is among a set of supported colors:</p><pre>enum Color {<br>  Blue = &quot;blue&quot;,<br>  Brown = &quot;brown&quot;,<br>  Orange = &quot;orange&quot;,<br>  Red = &quot;red&quot;,<br>}<br><br>const x = &quot;Pink&quot;;<br><br>if ([Color.Blue, Color.Brown, Color.Orange, Color.Red].includes(x)) {<br>  // Operations for supported colors<br>}</pre><p>This approach allows us to easily scale by adding more colors without cluttering the code or compromising readability.</p><p>These examples illustrate the importance of considering scalability in our code. Whether it involves enums, switch statements, or other scenarios, our goal is to ensure that our code can easily accommodate additional values or elements in a maintainable and readable manner.</p><h3>Modular Components</h3><p>Having a guideline for file length can be helpful in maintaining organized and manageable code. On my team, we follow the principle of keeping files under 500 lines, as recommended by our principal engineer. While it may not always be feasible to meet this limit, striving for smaller files can generally improve code readability and maintainability.</p><p>In some cases, you may come across files where a significant portion of the initial lines consists of import statements for various dependencies. Although this can contribute to the file length, it is a necessary part of the component’s setup.</p><p>However, for most scenarios, breaking down changes into multiple components is a preferred approach. It not only helps to improve code organization but also enhances the understanding of the code flow.</p><p>While adhering to a file length guideline is beneficial, it’s important to remember that it is not an absolute rule. If it’s not possible to meet the specified limit, it’s not the end of the world. The key is to strive for well-organized and maintainable code within the context of your specific project.</p><p>I must emphasize once again that the guideline of 500 lines is specific to my team’s conventions and may not be universally applicable. It’s important to follow your own team’s conventions and guidelines regarding file length, as they may have established their own recommendations based on their specific needs and preferences.</p><h3>React Hooks</h3><p>Before joining AWS, I didn’t have much experience with React hooks. I had heard about them but didn’t fully grasp their purpose or how to use them effectively. However, since joining AWS, I’ve started using React hooks regularly in my code reviews (CRs). The three most common hooks I use are useCallback, useMemo, and useEffect.</p><p>Here’s a simplified breakdown of these hooks:</p><ul><li>useCallback: It’s used to optimize and memoize functions, especially when passing them as dependencies to child components. By using useCallback, you can prevent unnecessary re-renders and improve performance. <strong>tldr: put your functions in useCallback hook</strong></li><li>useMemo: This hook is helpful when you have values that require complex calculations. It allows you to memoize these values, avoiding redundant computations and improving efficiency. <strong>tldr: if you need the value of variable </strong><strong>x but you need to perform a lot of computation to get to </strong><strong>x then put all that computation in useMemo and return x.</strong></li><li>useEffect: When you need to perform actions after each render cycle, such as fetching data or updating the DOM, useEffect comes in handy. It helps you handle side effects in a clean and organized way. <strong>tldr: when you want to execute lines of code after render() is called.</strong></li></ul><p>By utilizing these hooks appropriately, you can write more efficient, readable, and maintainable code. Stay tuned for a more detailed explanation of React hooks in my upcoming post.</p><h3>Bring variables and functions outside of the component’s scope</h3><p>If we have constant variables that remain unchanged during runtime and their values are known beforehand, it’s beneficial to move them outside of the component. This approach improves the readability and maintainability of the code.</p><p>Here’s an example:</p><pre>const WIDTH = 3;<br>const LENGTH = 3;<br>const nodeId = &quot;dropdown-menu&quot;;<br><br>function DropdownMenu() {<br>   // operations<br>}</pre><p>By extracting these constants from the component, it becomes easier to understand their purpose and usage. If these constants are used in multiple components, not just DropdownMenu, it&#39;s recommended to store them in a separate file for better organization.</p><p>Similarly, for functions, we can apply the same principle. If a function serves a general purpose that is unrelated to the specific component and doesn’t heavily rely on values within the React component, it’s a good practice to move it out of the component’s scope.</p><pre>const nodeId = &quot;dropdown-menu&quot;;<br><br>const sortAlphabetically = (array: string[]) =&gt; {<br>   // implementation<br>}<br><br>function DropdownMenu() {<br>   // operations<br>}</pre><h3>Remove comments and console statements</h3><p>Another important aspect to consider is the removal of any console.log statements that may have been left in your code. These statements are typically used for debugging purposes, and it&#39;s crucial to remove them before finalizing your code changes.</p><p>Additionally, it’s worth examining the usage of comments in your code. Ideally, your code should be self-explanatory without the need for comments. If you find yourself relying heavily on comments to make your code understandable, it may be a sign that the code itself could benefit from restructuring or refactoring. In my team, we rarely use comments except for occasional “TODOs” to mark tasks that need to be addressed in the future. However, even these comments are often replaced by creating specific tasks in our task management tool.</p><p>And that concludes some things I look out for. This list will probably grow with time as my responsibilities also grow with me. We shall see.</p><p>If you do want to learn more, I recommend <a href="https://mtlynch.io/code-review-love/">How to Make Your Code Reviewer Fall in Love with You</a>. A senior engineer in some distant Amazon org recommended it to me, and I thought it was great. Go check it out.</p><h3>Don’t feel pressured to post a CR everyday</h3><p>During the initial phase of my tenure at AWS, I felt a sense of pressure — created by myself — to submit code reviews on a daily or every other day basis. Being new to the professional environment, I was uncertain about what the expectations were, and I wanted to demonstrate my progress and productivity. With the freedom to manage my own time, I wanted to show that I was actively working towards completing tasks rather than engaging in unproductive activities.</p><p>As a result, I would submit code reviews regularly, even when my tasks were not fully accomplished. I saw it as an opportunity to seek feedback and clarify important implementation details that were not explicitly provided to me.</p><p>I remember one day, during one of my weekly meetings with my manager, she advised me that I didn’t need to submit code reviews at such a high frequency. At that point, I was likely submitting 5–7 revisions per task.</p><p>This was such a pivotal moment for me.</p><p>It was such a simple and obvious piece of advice, but it was truly a turning point. She emphasized the importance of seeking help and clarifications before submitting code reviews. If I was unsure about using a backend API, the acceptance criteria for a task, or the feasibility of a UX design, all I had to do was ask. After that moment, I immediately put my manager’s advice into action and the number of my revisions dropped.</p><p>Just by communicating with my team, we can cut back a lot of back and forth that we do in CR comments. We can be aligned in our vision for what has to happen, and it saves so much time.</p><p>Additionally, every time I post a CR nowadays, the acceptance criteria will always be met — to the best of my knowledge. It’s funny. Just because our code looks like it works, it doesn’t necessarily mean it will be approved. I have learned that lesson over and over again. But again, to the best of my knowledge, I check all the acceptance criteria for the task. I stopped posting CRs that were incomplete. I stopped asking for help through CRs. Honestly, it was a game-changer.</p><p>Now, there are many days when I don’t submit any code reviews for a few days, and I no longer panic. It has become a normal practice for me. I understand the value of taking time to perfect my code reviews, as I appreciate that my team members are dedicating their own valuable time to review my code. I strive not to waste their time by submitting subpar work.</p><h3>That’s it from me.</h3><p>Thanks for learning with me. If you follow me, thanks for sticking around. I hope you continue to stick around so we can continue our journey to success together :)</p><p>I will admit that the reason I have not been posting as often is that I felt a bit fraudulent. It’s no secret that I started this blog as a completely inexperienced college kid. I shared things as I learned them, and everything I have shared and will continue to share is always going to be backed by research and experience.</p><p>But one of the biggest lessons I learned in my ten months at AWS is that I have barely scratched the surface. There is so much that I do not know. As I said throughout this post, I have had my code critiqued countless times. That process has undoubtedly made me a better engineer, but it also killed a lot of my morale and any authority that I felt I had. It became difficult to share things I have learned because it almost seemed like I am the last person anyone should be asking for guidance. Instead, go to the senior-level engineers and the principal engineers for help.</p><p>However, now, I am once again in a place where I feel confident in myself and my knowledge. I am once again in that spirit of wanting to raise the bar for myself and continue to learn.</p><p>I also realize that there is space for me in this community. As an inexperienced newbie engineer at one of the biggest companies in the world, I presume there’s an audience that wants to hear about what I’m learning and the experiences I go through. You can learn along with me.</p><p>Additionally, while more senior engineers are undeniably more knowledgeable than I am, I think they can sometimes forget — to no fault of their own — that what they consider “common knowledge’ is different from how I define ”common knowledge”. I’m starting with a clean slate. If they’re explaining concepts using a bunch of concepts I don’t understand, then their entire explanation does not really improve my understanding. So for me, I feel that I can go back to the basics and, over time, build our understanding of higher-level concepts.</p><p>So thank you for stopping by :) Let’s keep learning<br>Kyle</p><p><em>Follow me on </em><a href="https://www.linkedin.com/in/kyle-deguzman-0a0047137"><em>LinkedIn</em></a><em><br>Find me on Figma, GitHub, and Twitter @kyledeguzmanx</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cc48ca81277" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/how-i-approach-code-reviews-as-a-reviewee-4cc48ca81277">How I Approach Code Reviews as a Reviewee</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How does Load Balancing improve an application’s availability, scalability, and performance?]]></title>
            <link>https://medium.com/@kyledeguzmanx/how-does-load-balancing-improve-an-applications-availability-scalability-and-performance-a25bba7ba5c?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/a25bba7ba5c</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Sun, 26 Feb 2023 18:46:37 GMT</pubDate>
            <atom:updated>2023-02-26T18:46:37.398Z</atom:updated>
            <content:encoded><![CDATA[<h4>Learn with me</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*PViNBowlWpuesJUj" /><figcaption>Photo by <a href="https://www.instagram.com/saltsupgourmetsalts/"><strong>Piret Ilver</strong></a></figcaption></figure><p>Hey friends and fellow web developers,</p><p>If you’re in the infancy of your tech career like I am, you probably realize there’s a lot to learn but there’s not really a comprehensive list of all the things you can possibly learn. So allow me to be a resource, and let me help you out with that.</p><p>Today, we’re talking about Load Balancing. Load Balancing is a popular and common practice everyone uses to evenly distributes work across multiple servers. By distributing that workload across multiple servers, we can improve our application’s reliability, scalability, and performance.</p><h3>Let’s dive deeper into it.</h3><p>If you didn’t know, applications are run using multiple servers. You can think about Twitter, Medium, Facebook, and Amazon. All their data is hosted on multiple servers. This is done for a few reasons.</p><p>First, let’s think about redundancy. Redundancy is a concept you will hear all the time. In this context, it means we have multiple copies of the same resources. <strong>It’s redundant. </strong>This is beneficial because if something goes wrong with a data center or a server, you can feel assured that there are copies of your resources on another server. Your resources will always be safe (<em>unless I suppose, all these data centers and servers collapse at the same time. But that’s really unlikely</em>).</p><p>With the same idea in mind, these major companies also use multiple servers to handle users’ requests. If a server goes down, the entirety of Facebook or Twitter shouldn’t collapse. That would be a very fragile system. So instead, these applications are hosted on multiple servers. It improves the availability of your application. <em>And if it&#39;s not obvious, availability just means that your application and its features are usable and fully functional.</em></p><p>Going further, these applications are hosted on multiple servers that are sprinkled all over the globe. Why is that needed? I live in California, USA. Let’s imagine Facebook has data centers and servers in the US and in Asia. If I make a request on Facebook, should my request be sent to the servers in the US or in Asia? Ideally, it would be the servers in the US because I would get a faster response time.</p><p>It’s interesting though. Because what if the server in the US has heavy traffic but the server in Asia has low traffic? It can definitely be the case that the server in Asia could deliver me a faster response.</p><p>These are details that engineers have to think about. It’s especially true when their applications are handling hundreds of thousands or millions of requests at a given moment.</p><h3>So now let’s talk about a load balancer and load balancing.</h3><p>Here’s an analogy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*fPNaxOYQr07uFeU3" /></figure><p>You’re in a store or maybe a market. There are a hundred people in line waiting to checkout and pay for their goods. Each cash register, in partnership with the clerk, represents a single server.</p><p>Obviously, with more cashiers opened, we can process more customers faster. With this mentality, we see that companies use multiple servers.</p><p>But here’s a curveball: imagine we have 10 cashiers opened, but for some reason, all the customers are waiting in line for only one or two of them. The remaining cashiers are just idle. That’s a waste of resources.</p><p>This is where a <strong>load balancer</strong> comes in. It will take those 100 users and their requests, and evenly distribute them across different servers. So for example, if we have 10 servers, you could imagine it would give each server 10 user requests to handle. <em>That’s an oversimplification, but that’s the general idea.</em></p><p>By evenly distributing users&#39; requests, also known as <strong>load balancing</strong>, it makes sure a single server isn’t doing all the work. That means improved latency and response times because the user isn’t waiting as long for a server response. Going further on improved performance, load balancing can also help us mitigate customers being impacted by issues with our servers. If something goes wrong with a server and it&#39;s negatively impacting customers’ experience, we can direct them to other servers while we get the issue fixed.</p><p>Also, with this setup, it means it&#39;s easy to scale. If we want to add more servers, we can add the server to our <strong>server pool</strong> or <strong>server farm </strong>and the load balancer will immediately start giving it requests to handle. It’s that easy. And if we have to remove servers, due to lower traffic than anticipated or maybe due to server maintenance, we can do that.</p><p>And there you go. That’s load balancing broken down and simplified.</p><p>Load balancing is just one of many reasons why cloud computing solutions like Amazon Web Services, Microsoft Azure, and Google Cloud Platform are so mainstream. Personally, before I started working for AWS, I didn’t understand exactly what they did. I also didn’t realize how big they were. Honestly, it’s insane how all these companies we know like Hulu, Coca-Cola, and Uber all work with cloud services. Even the Superbowl and the new Avatar movie worked with AWS. Everyone works with cloud computing companies, and it&#39;s interesting to be part of that conversation and learn more about how the modern internet works.</p><p>Anyway, cheers to you.</p><p>Let’s grow together and succeed together in 2023. I’m approaching 8 months at AWS, as a recent new grad, and I’m excited to keep everyone in the loop and share the cool things I learn.</p><p>Have a good day everyone.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a25bba7ba5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web Sockets: The Protocol You Can Use for Real-Time Applications]]></title>
            <link>https://medium.com/@kyledeguzmanx/web-sockets-the-protocol-you-can-use-for-real-time-applications-9c3adfa1eaae?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c3adfa1eaae</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Thu, 17 Nov 2022 13:51:44 GMT</pubDate>
            <atom:updated>2022-11-17T13:51:44.975Z</atom:updated>
            <content:encoded><![CDATA[<h4>Web Socket Protocol vs HTTP</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*JfS_ytysDokdaqLq" /><figcaption><a href="https://www.instagram.com/israelpalacio/">Photo By Israel Palacio</a></figcaption></figure><p>Hey friends,</p><p>Today, we are talking about something pretty cool. We’re talking about a communication protocol that allows a client (like browsers, apps, etc) to receive data from a server even when the client never asked for it.</p><p>For example, think about a messaging app like Facebook Messenger or Whatsapp. If you really think about it, do you think the client is constantly nagging at the server and asking “Hey, is there anything new for me?” Probably not. If it was, that means the client has continously send HTTP request to ask for an update. That’s a lot of requests. Especially if you consider, if this is the case, how frequently would the client ask the server for an update? Every 2 minutes? Every second? Every milisecond?</p><p>Instead, the solution <em>may be</em> web sockets. With web sockets, the server can communicate with the client and send over information without the client asking for it.</p><p>This is has so many different use cases like multiplayer games, app notifications, real-time collaborative applications, and so on. Let’s talk about it.</p><h3>HTTP Protocol</h3><p>Just to give you some context — in case you’re totally new to the subject — let’s talk about the HTTP protocol.</p><p>The process usually looks something like this:</p><p>The user, through a client like a browser or application, is interacting with some software. As expected, the user might click things, type on their keyboard, or offer any other form of input. And as computers do, they compute things. They offer responses to the user’s input.</p><p>Now sometimes, these responses require data that’s stored elsewhere. For example, weather applications. If you’re looking for weather data on an a website or android app, that app is just visually presenting information that’s stored on some server. Or think about social media. All that data — who liked what post? how many followers does X have? what did people comment? — yeah, all that data is stored on servers. Obviously, that data isn’t stored on your computer. It’s coming from somewhere.</p><p>Usually, to access such data, we use HTTP.</p><ol><li><strong>The user performs an action.</strong> For example, they click my follower count to see who is following me.</li><li><strong>That action triggers an HTTP request that gets sent to the server</strong>. For example, the social platform will tell the server it needs data on who follows me.</li><li><strong>The server receives the request, interprets it, and then seeks out the resources to fulfill that request</strong>. Basically, it gets that data from wherever it gets its data. Maybe the backend will also manipulate the data. Maybe the data is in a raw form, and the data you need must be extracted from it. Sometimes thats the case. Sometimes data handling is also done on the front-end. I guess it just depends.</li><li><strong>The server successfully gets the data that the client asked for and sends it back.</strong></li></ol><p>That’s the gist of it. This is how the internet works.</p><p>One very important detail to note is that before the client actually talks to the server and requests something, <strong>the client has to formally form a connection with the server</strong>.</p><p>The client has to say, “Hey, can we talk? Can we form a connection so we can talk? ” The server will say, “Yeah, sure. What do you need?” And then the client tells the server what it needs. The server gets whatever the client needs, sends the data to the client, and then the server says “Bye”. <strong>The connection is terminated</strong>.</p><p>Another important detail to understand is that, with HTTP, <strong>the client is the one initiating the conversation</strong>. The server is never going to be the one that talks to the client first. This evidently means that if the client needs someting, it has to ask for it.</p><p>Again, think about notifications. They notify you when there’s an update. How are you supposed to send an HTTP request and ask for that update if you don’t know when the update is going to arrive? It could be in 2 seconds, 2 hours, or 2 days.</p><p>Lastly, another detail to understand is the structure. The client talks. The server responds. The conversation is killed. It’s always going to take that form. They take turns. It can never be the case that either party will talk 2 or 3 times consecutively.</p><p>All that said, let’s talk about web sockets.</p><h3>Web Sockets</h3><p>Web sockets are a persistent connection between client and server.</p><p>Similar to HTTP, the client will say, “Hey. Can we talk?” The server will say okay. <strong>The connection will become established.</strong></p><p>At this point, <strong>either party can talk</strong>. The client can send infinitely many requests or the server can send over some data infinitely many times. Or nobody could talk. That’s also an option.</p><p><strong>They don’t have to take turns</strong>. The server does not have to wait for the client to explicitly request something in order to give the client data; the server can just give the client data. We call this a <strong>bi-directional </strong>line of communication.</p><p>And unlike HTTP, after the server responds, the connection between client and server is not terminated. This is why we call it a <strong>persistent </strong>connection. The only way this conneciton can break is if either party disconnects.</p><p>Using web sockets, we can create real-time applications. Think about productivity applications and collaboration tools where you and your peers can edit the same documents, presentations, design files, or spreadsheets in real-time. You see their mouse cursor move, and you see the changes they make in real-time.</p><p>Web sockets allows us to get this real-time data without making HTTP calls every 0.0001 miliseconds. We need the freshest data possible.</p><p>Thanks for reading.</p><p>Lately, I’ve really been into learning about performance, system design, and software engineering techniques. Whenever I see other engineers talk about concepts I’ve never heard of, rather than being anxious about it, I get excited. It’s a fun time. Hope you stick around and learn with me.</p><p>Kyle</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c3adfa1eaae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Are Optimistic Updates?]]></title>
            <link>https://medium.com/@kyledeguzmanx/what-are-optimistic-updates-483662c3e171?source=rss-cb80609ba9e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/483662c3e171</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Kyle DeGuzman]]></dc:creator>
            <pubDate>Wed, 16 Nov 2022 13:37:25 GMT</pubDate>
            <atom:updated>2025-12-01T00:09:00.660Z</atom:updated>
            <content:encoded><![CDATA[<p>How Optimistic Updates May Improve Responsiveness</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*XbHUvCB0s8BFZ1Oj" /><figcaption>Photo By <a href="https://www.instagram.com/absolutvision/">AboutVision</a></figcaption></figure><p>Hello friends and fellow engineers,</p><p>A few weeks ago, I was first introduced to the very interesting concept of “optimistically” updating the user interface (UI). It’s a technique everyone uses to improve the user experience by making the application feel like its more responsive.</p><p>There are many times within applications when a user performs an action — like clicking buttons or providing some form of input — and that triggers the application to send a request to a server. In this scenario, the request is going to give some data to the server. For example, if you like a post on Instagram, Instagram will talk to the server and tell the server that you liked that post.</p><p>The idea with optimistic updates is that the application will assume that the server will respond “It was a success. You accomplished your goal. Whatever you needed me to do, I did it.” So again, taking Instagram as an example, Instagram will show that you liked the post. A transparent heart will overlay the Instagram post and the heart icon will turn red. Instagram does this, <strong>optimistically</strong>; they visually show you that you liked the post without first getting confirmation from the backend that that entire operation — of liking the post — was accepted.</p><p>It’s such a simple idea, but I thought it was fascinating so I wanted to share it with everyone.</p><p>That’s the gist of it. If you want some more details, let’s walk through it.</p><h3>Walkthrough</h3><p>You’re on a social-sharing platform. It could be Twitter, Instagram, YouTube, Facebook, Medium... <em>You get it</em>. Again, we are looking at the ability to like a post.</p><p>When the user hits the heart or the thumbs-up icon to like a post, the client (browser/app) sends information to a server and lets the server know that the user liked that post. The server needs to know these things so it can handle the data and ultimately share this data with other users.</p><p>On top of giving the server that information, the app has to update the UI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ELklsA4YwEnMsYyUoqsjKQ.png" /></figure><p>If I liked this post, the heart icon should be filled in like so:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZVFZ2faJAIfc5qqcrI_8Ug.png" /></figure><p>Notice that on social platforms, as soon as you like something, a response is immediately returned to you. Some visual indication will be given to let the user know that they successfully liked the post. <strong>In other words, a UI change happens to reflect a change in state</strong>.</p><p>This is an optimistic UI update.</p><p><strong>The user performed an action that changes the state</strong>. That action sends information to a server and the UI is optimistically updated to reflect the change in state. <strong>We say “optimistically” because we are creating this UI change with hope and optimism that the change in state will be accepted by the server</strong>. In this case, after liking a post, we optimistically color the heart red and hope that the backend accepts the user liking the post.</p><p>The fact is: we don’t always know if the change in state is going to be valid. Or we do not know if the information sent to the server will be valid or accepted. Instead of waiting for the server’s response — which would confirm that the change in state was successful— we just act like it was successful and we update the UI.</p><h3>Why do we do this?</h3><p>We do it for responsiveness.</p><p>If we waited for the server to tell us that the user action was successful before conducting a UI change, it would take an unacceptably long time. The product would appear laggy or buggy. The user experience would not be great.</p><p>If you like a post, it’s a better user experience to see that the heart icon immediately turns red — indicating you successfully liked the post. It would be an inferior user experience if you liked a post and then saw a loading spinner for a few seconds before seeing that heart turn red. Or it would be an inferior user experience if you liked a post and the heart didn’t turn red until 5 seconds later — when the server finally responds that it was successful.</p><p>Loading spinners or second delays are not an expected UI behavior for these types of actions. Nobody does that. It would make users think there’s something wrong with your product.</p><p>You don’t want that.</p><h3>And what if the server does say that it was an invalid action? What if an error is returned from the server?</h3><p>Everyone does optimistic updates, and products handle optimistic update failures differently. Maybe the solution is to just revert to the previous state? like an undo. Pretend the change never happened.</p><p>Or maybe the solution is to throw in a pop-up to indicate to the user that their action was invalid. There are so many ways you can go about it.</p><h3>In what scenarios can you use optimistic updates, aside from likes?</h3><p>Binary actions are great for optimistic updates. Like/No Like, Upvote/No Upvote. If the user interface optimistically updates the UI and it was a false positive — aka the server rejected the request — it’s no big deal. Just undo the like and decrement the like count. The consequence of a false positive isn’t going to massively impact the user experience or the application’s behavior. It’s a small fix.</p><p>On that note, you shouldn’t optimistically update the UI for actions that will cause major problems if a revert is required. No other component should be affected by a revert. We don’t want a domino effect where there’s a single point of failure. If that component fails, we don’t want the rest of the app to crash.</p><p>Another use case is when users — through some interface like an app — create data, update data, or delete data. The users might create, update, or delete data in the Front-End — and the consequences of that are reflected in the Front-End/User Interface. But let’s say that the consequences of those actions are sent to the server, and the server rejects them. This was an <strong>optimistic update. </strong>Again, it’s updating the UI before you know the server will accept the change in state. If the server rejects it, handle it. Revert it, put in an error pop-up, or do whatever you need to do.</p><p>Hopefully that all made sense.</p><p>It should be noted that optimistic updates aren’t meant to handle every single user-triggered event under the sun. There are some operations that should be handled client-side, and there are definitely some operations that should be handled by a server. Be intentional with how you do things. That’s all I have to say.</p><p>Hey team!</p><p>Good news! With 4 Amazon products and services under my belt, I’m now a mid-level engineer at Amazon! I started this blog in a very different place. I was an unexperienced university student learning front-end software development online. Nearly three years later, I have real-world industry experience and insights. Please support me and subscribe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*siv4E7XzGiRVAB1C" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=483662c3e171" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>