<?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 Samuel Babalola on Medium]]></title>
        <description><![CDATA[Stories by Samuel Babalola on Medium]]></description>
        <link>https://medium.com/@samuelbabalola?source=rss-3bfa2b97db79------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*I8O77OsLm5FC3tAH9fIP_g.jpeg</url>
            <title>Stories by Samuel Babalola on Medium</title>
            <link>https://medium.com/@samuelbabalola?source=rss-3bfa2b97db79------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:13:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@samuelbabalola/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[People, Programs, Products: Lessons from Running Web3 Bootcamps in Africa]]></title>
            <link>https://medium.com/@samuelbabalola/people-programs-products-lessons-from-running-web3-bootcamps-in-africa-7d9053df4e4c?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d9053df4e4c</guid>
            <category><![CDATA[education]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[operations]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Mon, 06 Oct 2025 20:05:00 GMT</pubDate>
            <atom:updated>2025-10-06T20:05:00.150Z</atom:updated>
            <content:encoded><![CDATA[<p>From writing code to running programs: what it taught me about people, systems, and ecosystems</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xPpD_fTN2FGMX3BGNubjSA.png" /></figure><p>In January 2023, I walked into Web3Bridge as a Solidity bootcamp student. I had just survived the intense three-stage assessment process and was eager to sharpen my technical skills. At that point, my world was about pushing code and solving logic problems. What I didn’t know was that within a few months, my role would flip and I would go from student to the person helping to run the very program I once enrolled in. That shift became the crucible where I learned more about people, systems, resilience, and leadership than I could have imagined.</p><h3>The Shift From Learner to Builder</h3><p>The transition started almost unexpectedly. During Cohort 9 (the one after mine), the media role opened up, and I stepped in to help with photography and video edits, not exactly my strongest suit, but I took it on. From there, operations responsibilities started piling into my lap: managing classes, checking on students, coordinating tasks, and even organizing their final capstone pitch day. We were a lean team then, and “doing what needed to be done” was the only way forward. I remember one midnight when the students hadn’t eaten all day because they were still debugging their assignment. I walked in to find them scribbling logic on the whiteboard, one sighing heavily, another with his hands on his head in frustration, and yet still pushing. Those were the moments that showed me how much grit lived inside that space and how much responsibility came with creating an environment for it to thrive.</p><h3>Refactoring the Way We Worked</h3><p>By Cohort 10, my role had shifted completely. I was no longer just the student who once coded through the nights; I was the one coordinating admissions, running daily operations, and managing welfare. Admissions alone was a whole system: originally, we had a three-stage process (a mini-project, a technical and character interview, and a blockchain fundamentals test). The process was thorough, but it was time-intensive and often difficult to align with our calendar and onboarding schedule. For Cohort 10, I executed the shift to a two-stage process, moving the blockchain fundamentals test into the first set of class sessions. This adjustment made decision-making faster without compromising on quality. I interviewed, graded, and onboarded students into our Discord channels myself. Not glamorous, but it mattered.</p><h3>Building Systems That Could Breathe on Their Own</h3><p>Systems became the difference between “busy” and “scalable.” One of the systems I’m proudest of was Classmate, a decentralized app for attendance and assessments. I helped build version one as a developer, then later managed the team that shipped version two. Classmate wasn’t just a tracker; it minted NFTs for attendance, logged assessments, and gave students and mentors dashboards they actually used. It gave us a reliable source of truth and clean reporting for sponsors in a way that spreadsheets never could.</p><p>The same mindset powered payments. Early on, we relied on manual transfers of registration fees with the help of our community manager until an impersonator emerged on Telegram and began targeting applicants. We needed a single, safe flow. I built a Node.js backend integrated with Flutterwave and logged transactions to Google Sheets so leadership could track payments at a glance. The dev team later upgraded the stack (database + admin dashboard) and wired it into the registration portal. Onboarding became smoother, theft risk collapsed, and ops could focus on programs instead of chasing receipts.</p><p>But the most important systems weren’t just software. As the team grew past 30, I had to introduce weekly strategy and reporting sessions with department leads: tracking progress, surfacing blockers early, and planning what came next. We documented processes so success didn’t live in one person’s head. We used those meetings to plan marketing pushes for upcoming cohorts, align KPIs, and ensure the right signals flowed to leadership. That rhythm created trust enough that leadership could travel and know the work would hold. Structure replaced scramble; calm replaced duct tape.</p><h3>The People Side of Operations</h3><p>Through all of it, I kept learning the same lesson: people are the strongest currency. Some days, I was the strict coordinator: “Yes, you still have to push your code to GitHub and submit your tasks even if your internet is slow.” Other days, I was the counselor, sitting with someone who felt stuck and walking line-by-line through a problem. Knowing when to push and when to pause became a skill of its own.</p><p>The clearest proof was our alumni flywheel. Graduates who had absorbed the culture, grit, excellence, and community came back as mentors after gaining real-world experience. Not because they had to, but because they wanted to. Their return built continuity: new students saw what was possible, and old ones found meaning in giving back. That loop became more valuable than any tool we built. We invested in their welfare; they invested back into the next cohort, and people turned into momentum.</p><h3>How Product Thinking Crept Into Everything</h3><p>Running programs also trained a product muscle; the discipline of defining problems, scoping clearly, shipping fast, and iterating from feedback. Each cohort ended with a capstone phase where students are grouped into teams to build real projects from scratch. I wrote PRDs, ran standups, and helped them remove blockers along the way. Some of those projects later won ecosystem grants, not because we chased hype, but because we picked real problems and built toward them.</p><h3>Transparency That Opened Doors</h3><p>On the partnership side, one of the best lessons I learned came from my boss: transparency builds trust faster than perfect numbers ever could. That mindset shaped everything from reports to KPIs to proposals. When I prepared the Starknet education proposal, I leaned on that principle: clear outcomes, no embellishment, and in our reports, just what we’d achieved and learned. The proposal got approved, and the four-week masterclass saw students building projects in Cairo that later won product grants. The same approach deepened our relationship with Lisk. After reviewing our reports and seeing how clean and consistent our operations were, they extended their sponsorship for multiple cohorts. I learned that ecosystems reward value; do the work, align with goals, report honestly, and support compounds.</p><h3>The Chaos That Built Character</h3><p>Of course, not every day was clean systems and neat solutions. Some days were messy, exhausting, and frankly overwhelming. I remember Cohort 10 vividly because we didn’t yet have our own clinic. Many students fell ill during those weeks, and I found myself driving them to hospitals, checking on their treatments, and making sure they got back on their feet. In other moments, it was hackathons like the Web3Lagos Conference hackathon where I had to personally oversee most of the ops work: getting apartments for hackers ready, hauling beds and tables, setting up internet, security, and power. I even drove a truck to move chairs and equipment. It was three or four days of nonstop logistics, the kind that leaves you bone-tired but oddly proud when you finally sit down.</p><p>Those lows tested me, but they also reshaped me. I started out as a “deep work” person; one task at a time, finished end-to-end. Operations erased that luxury. I had to hold multiple moving parts in my head and still show up with clarity. Some days were not smooth, but over time, it built me back up into someone who could juggle chaos and deliver.</p><h3>Snapshots Worth Remembering</h3><p>The highs, though, are what make me smile, hearing that projects across multiple cohorts secured grants from Lisk, Starknet, and others, whether they began as cohort capstones or individual initiatives. Watching alumni return as mentors or land roles and thrive. Seeing junior staff grow into confident leads. And the quiet wins: buying laptops for students who needed one, paying subscriptions to remove small barriers, and late-night meetings with students that turned confusion into clarity. Those are the snapshots I carry.</p><h3>From Debugging Code to Debugging Systems</h3><p>If I try to name the real change in me, it’s this: I went from debugging code to debugging systems. From executor to builder. From “the person who can do it” to “the person who can make it repeatable.” Weekly reporting, clear ownership, documented processes, those weren’t just checklists; they were the scaffolding that made scale humane and made trust possible.</p><p>Sometimes I think back to that first day in 2023, just a student, eager to code. Two years later, I’d written PRDs, shipped internal tools, run cohorts end-to-end, negotiated with partners, documented processes, built a payments system, and helped design the structure that kept everything steady. There were high days: grants, sponsorships, thriving alumni. There were low days; hospital runs, facility upkeep, logistics that stretched me thin. Through it all, one thing stayed constant: purpose.</p><p>The purpose of helping people grow.</p><p>The purpose of building systems that outlive improvisation.</p><p>The purpose of proving that impact in tech isn’t hype; it’s how many people rise because the system you built made room for them.</p><p>If these two years taught me anything, it’s this: ecosystems aren’t built by protocols or products alone. They’re built by people willing to show up, take ownership, and create space for others to thrive. That’s the lesson I’ll always carry with me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d9053df4e4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Thinking in Action: How a Food Delivery Startup Solved the Wrong Problem]]></title>
            <link>https://medium.com/@samuelbabalola/design-thinking-in-action-how-a-food-delivery-startup-solved-the-wrong-problem-e4fe431ff48d?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4fe431ff48d</guid>
            <category><![CDATA[business]]></category>
            <category><![CDATA[storytelling-for-business]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Sat, 17 May 2025 12:50:46 GMT</pubDate>
            <atom:updated>2025-05-17T12:50:46.080Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why the best product ideas don’t start with solutions, but with seeing people clearly</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xG1b4ys_Qn9oE0JTIAjZBA.png" /></figure><p>Dayo was the product lead at a fast-growing food delivery startup in Lagos. Think Uber Eats, but for jollof rice, shawarma, and amala on demand. His team was busy optimizing delivery routes and rolling out sleek app features. But customer satisfaction metrics were flat. Worse, support tickets were piling up with complaints that didn’t seem to match any bug or outage.</p><p>Everyone assumed the issue was late deliveries. But Dayo wasn’t so sure. So he did something simple but uncommon: he went outside.</p><h4><strong>Empathy: Seeing Beyond the Metrics</strong></h4><p>Dayo started tagging along with dispatch riders, quietly observing. He sat in restaurant pickup zones. He watched customers receive their orders.</p><p>What he saw surprised him. Many customers weren’t upset about lateness alone. They were anxious. They kept calling riders mid-route. Some even tracked them obsessively on the map. One woman, standing at her gate, said to the rider: “I just wasn’t sure you’d find me.”</p><p>The issue wasn’t just logistics. It was <strong>trust</strong>.</p><h4><strong>Define: Articulating the Real Problem</strong></h4><p>Most of the team had been focused on ETA accuracy. But the real user need was different:</p><blockquote>”How might we help customers feel more in control and reassured while waiting for their food?”</blockquote><p>This small shift reframed everything. It wasn’t just about being fast. It was about <strong>feeling reliable</strong>.</p><h4><strong>Ideate: Exploring the Right Solutions</strong></h4><p>Now that the team had a better question, Dayo ran an ideation sprint. They mapped out dozens of ideas:</p><ul><li>A progress bar showing food prep and transit stages.</li><li>Friendly driver profiles with messages like “Olu is 7 minutes away”</li><li>Smart status updates triggered by geo-fencing (“your rider is around the corner!”)</li><li>A feedback feature that lets users share how confident they felt about the delivery</li></ul><h4><strong>Prototype: Build Just Enough to Learn</strong></h4><p>They picked two of the best ideas to test fast:</p><ol><li>A 3-stage progress bar: Food being prepared &gt; Rider picked it up &gt; Arriving soon.</li><li>A short profile card with the rider’s name, photo, and a welcome message.</li></ol><p>Designers mocked it up in Figma. Engineering spun up a basic test environment using feature flags so only 20% of users would see it.</p><h4><strong>Test: Put the Prototype in the Wild</strong></h4><p>The new features went live quietly. Then they watched what happened.</p><p>Support tickets around delivery anxiety dropped by 30% among the test group. In user interviews, people described feeling “calmer,” “more aware,” and “in the loop.” No change in speed. But a huge change in perception.</p><h4>Implement: Shipping the Solution at Scale</h4><p>Armed with promising feedback, the team moved from testing to execution.</p><p>They refined the progress bar messaging; <em>“Rider is waiting at the restaurant”</em> performed better than the generic <em>“Picked up.”</em> A new rider message field was added so drivers could share context like <em>“I’m parked by the yellow building.”</em></p><p>Then they pushed the changes live for everyone.</p><p>Engineering fully integrated the progress bar and profile card into the main order flow. Product marketing added subtle in-app copy to reassure users: <em>“We keep you in the loop, so you can relax while your food is on the way.”</em> Support teams updated scripts to reference the new tracking experience.</p><p>It was no longer an experiment. It was the product.</p><p>Within weeks, customer satisfaction scores rose by 22%. Not because the food got faster, but because customers felt seen, heard, and informed.</p><h4><strong>Iterate: </strong>Improving What’s Already Working</h4><p>Post-launch, the team continued watching. They discovered that users on slower networks were dropping off before the rider profile loaded. So they optimized asset size and caching.</p><p>They added localization to the rider greeting. <em>“Olu is 7 minutes away”</em> became <em>“Olu dey come now”</em> for users who preferred Pidgin.</p><p>Small improvements, driven by real usage patterns, not assumptions.</p><h4><strong>Inputs Lead to Better Outputs</strong></h4><p>None of this would have happened if they had started with solutions. Instead, they started with <strong>empathy</strong>. They used field research, observation, and conversation as inputs. They turned those into real definitions, then tested their way into the right answer.</p><p>Design thinking isn’t a theory. It’s a toolset for solving real-world problems, and it works.</p><p>The next time you’re stuck in a product loop, trying to guess what feature will finally click, ask yourself:</p><ul><li>Have we observed our users in their natural environment?</li><li>Do we understand their emotions and fears?</li><li>Are we solving the right problem?</li></ul><p>Because in product, like in life, understanding often matters more than speed. And that understanding starts with empathy.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4fe431ff48d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Thinking: How Empathy Shapes Better Products]]></title>
            <link>https://medium.com/@samuelbabalola/design-thinking-how-empathy-shapes-better-products-3b3135981ac1?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b3135981ac1</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[business]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Sat, 17 May 2025 11:30:35 GMT</pubDate>
            <atom:updated>2025-05-17T11:30:35.146Z</atom:updated>
            <content:encoded><![CDATA[<h4>Understanding the role of empathy, problem framing, and iteration in modern product development</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YRY_y3fnAvjqcNBDzjepXQ.png" /></figure><p>In a world that celebrates speed and innovation, it’s easy to forget one essential truth: building great products isn’t just about great ideas, it’s about solving real problems for real people. That’s where design thinking comes in.</p><p>Design thinking is more than a framework. It’s a mindset; a way of seeing, questioning, and creating that anchors product development in empathy, exploration, and iteration. When applied well, it shifts teams from guessing what users want to knowing what users need.</p><p>Let’s walk through the five key phases of design thinking and how they apply to building products that truly work for people. At each stage, we’ll explore real-world applications and how input (data, research, insight) drives output (solutions, features, iteration).</p><h4>Empathize: Seeing the Problem Through Their Eyes</h4><p>Design thinking starts with empathy. Before you build anything, before you define the problem, you listen. You observe. You engage. The goal here is to understand your users&#39; world without bias or assumption.</p><p><strong>Real Application: </strong>When IDEO worked with a healthcare provider to improve the patient experience, their team shadowed patients from check-in to discharge. What they learned wasn’t in any data dashboard: patients felt powerless, confused, and anxious. That insight became the foundation for better signage, staff interaction scripts, and waiting room design.</p><p>Inputs at this stage include observational research, user interviews, and empathy maps. The outputs are emotional insights, behavioral patterns, and unexpected pain points.</p><p>Empathy is not about asking what users want. It’s about understanding their lives deeply enough to uncover what they need.</p><h4>Define: Framing the Right Problem</h4><p>Empathy reveals. Definition focuses. Here, we distill our observations into a clear, actionable problem statement. This isn’t just a task. It’s a discipline. A poorly framed problem leads to wasted time and features no one uses. A well-framed one unlocks creative, relevant solutions.</p><p><strong>Example: </strong>Instead of saying, “We need to build a faster checkout process,” you might reframe it as: “Busy users need a way to reorder essentials with minimal steps, even when distracted.”</p><p>Inputs at this stage include synthesized user research, stakeholder needs, and business constraints. The outputs are a problem statement, design criteria, and alignment around purpose.</p><p>Strong product teams don’t chase features. They chase clarity.</p><h4>Ideate: Exploring the Possibilities</h4><p>Once the problem is clear, the team enters a second divergence, not of empathy, but of imagination. Now, it’s about exploring a wide range of solutions, before narrowing down again to the most promising ones.</p><p>In this phase, the goal is volume, not perfection. You want breadth, a wide range of solutions and ideas. Wild ideas are also welcome because they often uncover unexpected paths to real solutions.</p><p><strong>Example: </strong>When Airbnb founders struggled to get listings, they didn’t redesign the app first. They flew to New York and manually helped hosts take better photos. That “manual” idea became a powerful insight: better visuals drive trust, which drives bookings.</p><p>Inputs at this stage include a clear problem statement, cross-functional brainstorming, and competitive analysis. The outputs are potential solutions, idea clusters, and low-fidelity concepts.</p><p>Brainstorming isn’t fluff. When it is grounded in real need, it fuels innovation.</p><h4>Prototype: Build to Learn</h4><p>Prototypes aren’t final versions. They’re quick, cheap experiments.</p><p>At this stage, you move ideas from the abstract into something tangible. Wireframes. Mockups. Clickable demos. Paper sketches. The point is to learn quickly, not to perfect anything.</p><p><strong>Example: </strong>Figma famously built a simple prototype of multiplayer cursor interaction, not with full backend sync, but with fake cursors to test the feeling of collaboration. That test confirmed a core user delight long before engineering scaled it.</p><p>Inputs at this stage include prioritized ideas, UI/UX principles, and team constraints. The outputs are Low-fidelity product artifacts, early feedback loops, and faster learning cycles.</p><h4>Test: Validate and Refine</h4><p>Testing is where input and output loop together. It’s not just about getting approval. It’s about uncovering blind spots, confirming hypotheses, and seeing how real users behave with your prototype.</p><p><strong>Example: </strong>Before launching Gmail, the Google team tested rough versions with internal users and iterated rapidly based on feedback. They didn’t aim for perfection; they aimed for confidence that they were solving the right email problems.</p><p>Inputs at this stage include prototypes, real users, and usability test sessions. The outputs are validated assumptions, feature adjustments, and new insights for iteration.</p><p>Testing is not the end of the road. It is the beginning of iterations.</p><h4>Implement: Build What Matters</h4><p>Testing gives you confidence. Implementation delivers the value. This is the phase where your team moves from prototypes to real, shippable product experiences. It’s not about starting over but building what worked, grounded in user feedback and strategic clarity.</p><p>Implementation isn’t just “go build it.” It’s where design, engineering, and product work closely to bring validated ideas to life. The focus shifts to production-quality features, edge case handling, and technical feasibility at scale.</p><p><strong>Example: </strong>When Miro validated that real-time whiteboarding was helping distributed teams collaborate better, they didn’t stop at sticky-note simulations. They invested in building a robust, real-time canvas architecture, enabling users across the world to co-draw, co-edit, and even video chat seamlessly on the same board. The final product wasn’t just a tool, it became a shared visual thinking space, critical for remote teams.</p><h4>The Loop That Powers Product Innovation</h4><p>Design thinking isn’t a rigid process. It’s a continuous loop that adapts as you learn, build, and respond.</p><ul><li>Empathy reveals hidden truths. Not just what users say, but what they feel, fear, and hope for.</li><li>Those insights reframe the problem. They help you define what truly needs solving, not just what was asked for.</li><li>A focused problem unlocks better ideas. Creativity thrives when it has constraints and clarity.</li><li>Ideas become tangible through prototyping. Even a low-fidelity sketch is a step toward something real.</li><li>Prototypes invite real-world feedback. Not just opinions, but observable behavior and reactions.</li><li>Feedback reshapes your understanding and drives smarter implementation; real features, products, and systems built with confidence. And once built, these solutions return to users, where new needs, gaps, and possibilities emerge.</li></ul><p>Great teams don’t just move through this loop once, they cycle through it over and over. Not to chase perfection, but to build confidence that what they’re creating will truly work for users, for the business, and for the future.</p><p>In a world obsessed with solutions, design thinking brings us back to the soul of product work: solving the right problems, in the right way, for the right people. Empathy isn’t soft. It’s strategic. Testing isn’t extra. It’s essential. And iteration isn’t a waste. It’s the heartbeat of relevance.</p><p>Whether you’re building an app, a startup, or a system inside a large enterprise, design thinking helps you align with what matters most: the people you serve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b3135981ac1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Stages of a Tech Company and Why Product Strategy Must Evolve at Each Stage]]></title>
            <link>https://medium.com/@samuelbabalola/3-stages-of-a-tech-company-and-why-product-strategy-must-evolve-at-each-stage-7a731433412d?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a731433412d</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[building]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Tue, 22 Apr 2025 14:41:48 GMT</pubDate>
            <atom:updated>2025-04-22T14:41:48.223Z</atom:updated>
            <content:encoded><![CDATA[<h4>From finding product-market fit to scaling innovation, here’s how strong teams adapt their product approach as they grow</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qpi8IZVkLvmzfnSQ-wWGhQ.png" /></figure><p>In product management, context is everything. A strategy that works at a 10-person startup can quietly sink a growth-stage company. The leadership playbook that scaled your Series A product may choke innovation when you hit enterprise size.</p><p>So, how do you adapt?</p><p>Marty Cagan, in his must-read book <em>Inspired</em>, breaks down the three key stages of a tech company’s journey, each with its challenges, mindset shifts, and product realities. Understanding these stages doesn’t just make you a better product thinker. It helps you lead smarter, whether you’re in Web2, Web3, AI, or anything in between.</p><h3>Stage 1: Startups — The Race to Product-Market Fit</h3><p>At this stage, a startup isn’t a fully formed company, it’s a working hypothesis. Every decision is a bet. The product, the audience, the business model; all of it is being tested in real-time.</p><p>The central question is: <em>Can we build something people truly want, fast enough, before we run out of money?</em></p><p>You don’t need full organization charts or slick roadmaps. You need <strong>clarity, urgency, and obsessive customer discovery</strong>.</p><h4>What the Product Looks Like Here:</h4><ul><li><strong>The co-founder is often the acting product manager:</strong> At this stage, formal roles are fluid. The founder (or one of them) usually owns product decisions, gathers user feedback, prioritizes features, and works directly with engineers and designers.</li><li><strong>All focus is on finding product-market fit:</strong> The only thing that really matters is building something people actually want. Everything revolves around proving there’s a real, valuable problem and that your product is the right solution.</li><li><strong>You’re building MVPs, testing assumptions, and pivoting fast:</strong> This phase is messy by design. You’re validating ideas, running experiments, and constantly discarding what doesn’t gain traction. Speed of learning is more valuable than polished execution.</li><li><strong>The team is small, agile, and highly collaborative:</strong> Communication is fast, decisions are informal, and everyone wears multiple hats. There’s little process, but high energy and ownership.</li><li><strong>The goal is learning, not scale:</strong> You’re not optimizing for efficiency or reach just yet. The win here is fast insight: figuring out what works, what doesn’t, and where to double down.</li></ul><p>In this phase, product discovery is life or death. There’s no room for politics, and bureaucracy barely exists. But the downside? The pressure is immense. Resources are limited. And failure is frequent.</p><p>“Nothing else much matters until you can come up with a strong product that meets the needs of an initial market.” — <em>Inspired</em></p><p>The startups that win are the ones that build the right product before their runway ends. The ones that don’t? They burn out trying to scale something no one really wanted.</p><h3>Stage 2: Growth-Stage — Scaling What Works</h3><p>So you’ve found something people want. Now what?</p><p>Now comes the equally hard problem: <strong>scaling that success</strong>.</p><p>In this stage, startups morph into structured organizations. Engineering teams grow from 25 to hundreds. The product now has traction, and the market is listening, but it is also starting to break under the weight of scale.</p><h4>New Product Challenges:</h4><ul><li><strong>Tech debt from early decisions now slows you down:</strong> Quick hacks and scrappy infrastructure that once helped you move fast now become blockers. As the codebase grows, every new feature feels heavier to ship, and refactoring becomes unavoidable.</li><li><strong>Onboarding new hires and aligning teams becomes critical:</strong> As the team scales, unwritten or undocumented knowledge within the organization, often shared informally by word-of-mouth, no longer scales with it. New hires need structured onboarding, and cross-team alignment becomes harder to maintain without solid documentation and communication systems.</li><li><strong>Product teams start to lose sight of the bigger picture:</strong> With multiple squads or streams, it’s easy for teams to become feature factories, shipping in isolation, without a clear view of company-wide priorities or user experience consistency.</li><li><strong>Go-to-market strategies need to evolve:</strong> What got you early traction, word of mouth, hustle, and founder-led sales may no longer work at scale. You now need repeatable systems for growth: scalable marketing, sales enablement, pricing strategy, and deeper customer segmentation.</li></ul><p>As companies scale, teams often struggle to stay truly autonomous. Decision-making becomes slower, dependencies grow, and clarity blurs across functions. At this stage, product leaders must shift their focus from building products themselves to orchestrating alignment across teams. Suddenly, things like internal tools, scalable infrastructure, and clear cross-functional communication become just as critical as shipping new features. Without this foundation, momentum stalls not because teams lack talent, but because they lack clarity, systems, and autonomy.</p><p>“The signs of organizational stress are everywhere.” — <em>Inspired</em></p><p>The risk at this stage? You start acting like a feature factory, adding more, and more, without a clear product vision. Teams execute but don’t innovate. And the thing that made you special starts fading.</p><h3>Stage 3: Enterprise — Sustaining Innovation at Scale</h3><p>This is where the stakes get even higher.</p><p>Enterprise companies, the ones that <em>made it</em> now face their toughest challenge: <strong>how to stay relevant</strong>.</p><p>At this size, the company has already won one big game. But now, the internal focus shifts from growth to the protection of revenue, reputation, and brand. And this instinct often kills innovation.</p><h4>Common Enterprise Pitfalls:</h4><ul><li><strong>Decision-making becomes slower and more complex:</strong> As teams grow and structures become layered, more approvals and stakeholders are involved in decisions. This can make it harder to move quickly, even on simple changes.</li><li><strong>Product decisions often require broad alignment:</strong> With many voices at the table, decisions may lean toward compromise rather than clarity. While cross-functional input is valuable, it can sometimes lead to diluted outcomes when not well-managed.</li><li><strong>New ideas face more scrutiny and process:</strong> Established companies naturally develop a lower risk tolerance over time. This can lead to new ideas being slowed down or deprioritized, not because they lack merit, but because the system is designed to reduce uncertainty.</li><li><strong>Teams may feel less ownership and strategic clarity:</strong> As roles become more specialized and layered, some product teams may feel disconnected from the larger vision. Without clear ownership or strategic direction, it’s easy for motivation and creativity to wane.</li><li><strong>Leadership often looks outward for innovation:</strong> When internal efforts feel stuck, leadership may explore acquisitions, spin-offs, or dedicated innovation teams. While these can bring fresh energy, they often struggle to gain traction if core organizational habits remain unchanged.</li></ul><p>This is the phase where value capture takes over; endless tweaks and optimizations of existing products. But real product leadership means focusing on value creation: building what’s next, not just preserving what already exists.</p><p>“Strong tech-product companies know they need to ensure consistent product innovation.” — <em>Inspired</em></p><p>The enterprise companies that succeed, think Amazon, Netflix, and Apple, build repeatable systems for innovation. They fight stagnation by protecting creativity at scale, not just performance.</p><h3>Why Product Strategy Must Shift With Each Stage</h3><p>The secret to great product management isn’t a fixed set of tools or frameworks. It’s knowing what the product and the company actually need at any given stage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yNxjvH8yMUCD2_rO2Fo7Pw.png" /></figure><p>Great PMs evolve with their environment. They move from scrappy discovery to structured scaling to strategic innovation leadership without losing sight of customer value.</p><h3>Conclusion</h3><p>Each stage of a company comes with its own opportunities and traps. Startups need relentless clarity. Growth-stage companies need thoughtful systems. Enterprises need brave reinvention.</p><p>As a product leader, your real superpower is being able to zoom out to understand <strong>where you are, what your team needs, and how to move toward the next stage without losing your soul.</strong></p><p>The companies that win? They don’t just survive each stage, they evolve through them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a731433412d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ideas Are Everywhere, But User Needs Are What Matter Most]]></title>
            <link>https://medium.com/@samuelbabalola/ideas-are-everywhere-but-user-needs-are-what-matter-most-5f9dcbe78c7d?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f9dcbe78c7d</guid>
            <category><![CDATA[product-strategy]]></category>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Thu, 10 Apr 2025 15:33:09 GMT</pubDate>
            <atom:updated>2025-04-11T01:54:11.274Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why Great Products Start with Needs, Not Requests: A Guide for PMs, Founders, and Builders</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bShNvsdjTtN9ShT26fdW3Q.png" /></figure><p>As a product manager, you’re constantly surrounded by ideas. From feature requests and stakeholder brainstorms to feedback from users and bursts of internal creativity, ideas flood in from all directions.</p><p>But here is the truth:</p><p>Your job isn’t to chase ideas. It’s to solve the right problems.</p><p>That means filtering through the noise, understanding the <em>why</em> behind every request, and focusing relentlessly on real user needs.</p><h3>Ideas vs. Needs: What Every PM Must Understand</h3><p>Let’s start by making a crucial distinction</p><p>An idea is a potential solution, insight, or concept aimed at solving a problem, improving an experience, or creating new value for users or the business. It can apply to new product creation, feature enhancements, or process innovation.</p><p>User needs are the specific problems, desires, goals, and preferences that real people, which are your users or target audience, are trying to solve, fulfill, or achieve when they interact with your product or service. These needs are often shaped by their context, emotions, motivations, and the jobs they’re trying to get done.</p><p>Most failed products don’t fail because of bad ideas; they fail because no one validated the <em>need</em> behind those ideas.</p><p>Great product managers or leaders don’t just collect requests and put them on a roadmap. They uncover the root causes behind those requests, ask the hard questions, and deliver solutions that <em>actually matter</em>.</p><h3>Where Product Ideas Come From</h3><p>Product managers rarely sit around inventing features from scratch. In reality, most product ideas come from the ecosystem around the product: your users, your teammates, your data, and your market.</p><p>But not all ideas are equal. Some are biased. Some are urgent but narrow. Others are pure noise.</p><p>The job of a PM isn’t just to gather ideas; it’s to evaluate, validate, and prioritize them through the lens of user needs, business goals, and product strategy.</p><p>Let’s break down the four most common sources of product ideas and what to watch for in each:</p><h4>Employees</h4><p>Your colleagues across engineering, support, marketing, sales, or leadership are a goldmine of insights. They’re close to user problems, they see patterns, and they often have creative ideas for what to build next, but employee ideas are often shaped by internal bias in how <em>they</em> use the product or what <em>they</em> value most, which may not reflect real users.</p><p>Example:</p><p>Let’s say you’re building a collaborative text editor. You ask an engineer for feature suggestions. They suggest building a dark mode with Vim-style keyboard commands because they personally love using the terminal and code editors.</p><p>But your actual user base?</p><p>They’re marketers and copywriters who care more about simple formatting tools, comment threads, and real-time collaboration.</p><p>It’s a good idea but for the wrong user.</p><p>That’s why product managers must listen to employee ideas <em>and</em> cross-check them with user insights. Value the internal Point of View, but ground it in the customer reality.</p><h4>Metrics and Data</h4><p>Analytics is one of the most objective and scalable sources of insight. It reveals what users are actually doing, not just what they say they’re doing.</p><p>You’ll see:</p><ul><li>Drop-off rates</li><li>Feature usage patterns</li><li>Time spent on key flows</li><li>Abandoned carts, skipped steps, failed tasks</li></ul><p>But here’s the key:</p><p>Data is not insight; it’s a signal. And signals need interpretation.</p><p>Just because 70% of users drop off at step 3 doesn’t tell you <em>why</em> they’re dropping off.</p><p>To turn data into decisions, you need:</p><ul><li><strong>Data literacy:</strong> Understanding what the numbers mean and what they don’t</li><li><strong>Product context:</strong> Mapping metrics to user behavior, intent, and journey</li><li><strong>Qualitative pairing:</strong> Using interviews or observations to explain what the numbers can’t</li></ul><p>This is where PMs often work with data analysts or develop strong analytical skills themselves to spot meaningful trends, not vanity metrics.</p><h4>User Feedback</h4><p>Users are constantly giving feedback via surveys, support tickets, app reviews, Twitter threads, community forums, and even emails.</p><p>This kind of feedback is priceless. It gives you language, pain points, and emotional triggers directly from the people you serve, but most feedback reflects symptoms, not root causes.</p><p>For example:</p><p>A user might say, “The app is slow and frustrating.”</p><p>But the real problem?</p><p>They’re stuck at login because your password reset flow has poor error handling or their network is weak, and you’re not handling offline states well.</p><p>They report pain, but it’s your job to investigate the underlying issue.</p><p>That’s why PMs ask “why” multiple times. A complaint is a starting point for research, not the full answer.</p><h4>Clients and Customers</h4><p>Especially in B2B, clients are often vocal and powerful. Enterprise customers may request custom features, admin dashboards, integrations, or unique workflows that fit their team.</p><p>These requests often:</p><ul><li>Come from the sales team chasing a deal</li><li>Are backed by revenue, urgency, or contract terms</li><li>Sound like “must-haves” for closing or retaining a customer</li></ul><p>But here’s the caution:</p><p>Client needs may not align with the broader product vision or user base.</p><p>That requested feature might serve one big client but add complexity for everyone else. Or pull the team off the core roadmap.</p><p>PMs must evaluate:</p><ul><li>Is this request repeatable across multiple clients?</li><li>Will this help or hurt the core product experience?</li><li>Can we generalize the request into something useful for all users?</li></ul><p>Sometimes, it’s worth it. Other times, it’s better handled with a workaround, integration, or a scoped solution.</p><h3>Getting to the Real User Need</h3><p>When someone, a user, stakeholder, or teammate, says:</p><p>“We need this feature.”</p><p>Your job as a product manager is not to say “Yes” or “No.”</p><p>Your job is to ask:</p><p>“Why?”</p><p>Not once. Ask it again. Then again.</p><p>By the third or fourth “why,” you often uncover that what’s being requested is just the surface symptom and the real underlying need is something deeper, more meaningful, and more broadly solvable.</p><p>This approach is called the <strong>Five Whys</strong>, a technique used to dig beyond surface-level requests and uncover root causes.</p><p>Let’s walk through it with a real example:</p><p>“We need a dark mode.”</p><p>Seems simple. A UI preference, right?</p><p>Let’s apply the Five Whys:</p><p><strong>1st: Why?</strong></p><p>“Because users keep asking for it.”</p><p><strong>2nd: Why do they want it?</strong></p><p>“They use the app at night, and the screen is too bright.”</p><p><strong>3rd: Why is brightness a problem?</strong></p><p>“It strains their eyes and makes them stop using the app after a while.”</p><p>Aha. The real need isn’t a “dark theme” for the sake of it.</p><p>It is “reducing eye strain in low-light environments”.</p><p>Now you’ve unlocked broader solution options:</p><ul><li>Adaptive brightness</li><li>Low-light reading mode</li><li>A toggle based on time of day or device setting</li><li>Even accessibility presets for vision-sensitive users</li></ul><p>This is the essence of great product thinking:</p><p>You’re not just fulfilling feature requests; you’re solving real problems in the best possible way.</p><p>A feature is just one expression of a need.</p><p>Dig deeper, and you’ll often find smarter, more scalable solutions.</p><h3>Why Understanding User Needs is a PM Superpower</h3><p>Understanding user needs isn’t just a UX job; it’s a core product competency.</p><p>Here are the four key dimensions of user needs you must account for:</p><ol><li><strong>Usability:</strong> This is about ease of use. Can users complete tasks without frustration? Is the interface intuitive? A usable product reduces cognitive load, increases efficiency, and makes users feel smart, not overwhelmed.</li><li><strong>Aesthetics:</strong> Design isn’t just decoration; it shapes perception. A well-designed product feels modern, trustworthy, and enjoyable. People don’t just use it; they <em>want</em> to use it.</li><li><strong>Accessibility:</strong> Great products work for everyone. That means supporting users across different physical abilities, devices, languages, and contexts. Ignoring accessibility doesn’t just exclude people; it weakens the product.</li><li><strong>Emotional Satisfaction:</strong> How does the product make people feel? Empowered? Confident? Safe? People remember <em>feelings</em>, not features. Emotional satisfaction drives loyalty more than technical functionality.</li></ol><p>As a PM, internalizing these dimensions helps you think beyond “what we’re building” and into “what users experience.”</p><h3>Understanding User Research (Not Just Listening, But Learning)</h3><p>There are two core types of user research every product team should embrace:</p><h4>Attitudinal Research</h4><p>This focuses on what users say their opinions, preferences, and stated needs are.</p><p>Methods: interviews, surveys, focus groups.</p><p>Attitudinal research is great for exploring <em>why</em> users feel a certain way. But it’s often limited by what users can articulate (or even understand about their own behavior).</p><h4>Behavioral Research</h4><p>This focuses on what users <em>do:</em> actual actions, clicks, patterns, and behavior.</p><p>Methods: analytics, heatmaps, usability testing, session recordings.</p><p>It reveals where people struggle, what they ignore, and how they navigate through friction.</p><p>Great product teams use both.</p><p>Why? Because people say one thing… and do another.</p><h3>Why User Research Changes Everything</h3><p>User research isn’t a nice-to-have. It’s your north star. Done well, it turns intuition into insight and transforms opinions into decisions grounded in real user behavior.</p><p>Here’s how research gives product teams their edge:</p><h4>Validate Assumptions</h4><p>Every product team has assumptions about the problem, the user, or the solution, but assumptions aren’t strategy. They’re starting points.</p><p>Research helps you test what you believe to be true before investing time and resources in the wrong direction.</p><h4>Uncover Hidden Pain</h4><p>Users often don’t articulate their real problems clearly. They might report symptoms (“this is confusing,” “it’s slow”) but not what’s actually causing the friction.</p><p>Through interviews, observation, and behavioral analysis, research uncovers:</p><ul><li>Unspoken frustrations</li><li>Workarounds that signal poor UX</li><li>Emotional blockers like doubt, stress, or hesitation</li></ul><p>This is where great products differentiate, solving the pain users didn’t even know they had.</p><h4>Prioritize What Matters</h4><p>When you have a flood of feature requests, roadmap ideas, and stakeholder input, user research helps cut through the noise.</p><p>It clarifies:</p><ul><li>What users are struggling with most</li><li>What will drive real value</li><li>What’s urgent vs. what’s nice to have</li></ul><p>This ensures you’re not just shipping, you’re shipping what actually matters.</p><h4>Test and Iterate Faster</h4><p>It’s cheaper to fix a usability issue in a prototype than in production.</p><p>User research helps teams:</p><ul><li>Spot confusing flows before launch</li><li>Test multiple ideas without committing engineering time</li><li>Iterate with confidence based on real feedback</li></ul><p>The result? Faster cycles, smarter decisions, fewer regrets.</p><h3>Methods and Best Practices to Discover User Needs</h3><p>Understanding the importance of user needs is one thing. But how do you actually uncover them?</p><p>This is where UX research methods come in: tools and practices that help product managers and designers go beyond guesswork and into <em>real user insight</em>.</p><p>Here are some of the most effective methods used to identify, understand, and validate user needs:</p><h4>Surveys &amp; Questionnaires</h4><p>Surveys are structured tools that help you collect feedback from a large group of users at once. They’re best used when:</p><ul><li>You need quantitative input on how many users feel a certain way</li><li>You want to validate trends you’ve already seen qualitatively</li></ul><p>Well-crafted surveys can reveal what users like, what confuses them, and where their biggest pain points lie. However, beware of survey fatigue and always frame questions clearly to avoid biased responses.</p><p><strong>Use when:</strong> You need to gather input from a broad audience to inform prioritization or validate patterns.</p><h4>Interviews &amp; Focus Groups</h4><p>Talking directly to users is one of the most powerful ways to learn what they think, feel, and need.</p><ul><li>Interviews are one-on-one sessions that uncover personal stories, motivations, and frustrations. They’re great for emotional context.</li><li>Focus groups bring multiple users together to discuss a topic useful for collecting different perspectives in one session.</li></ul><p>These methods help PMs develop empathy and spot unarticulated needs the kind users can’t express in a survey but will describe in a conversation.</p><p><strong>Use when:</strong> You’re in discovery mode, trying to deeply understand the “why” behind user behavior.</p><h4>User Observation &amp; Shadowing</h4><p>This involves watching users interact with your product in real time, either in person or via screen recordings.</p><ul><li>Shadowing is observing users in their actual environment (e.g., at work), which gives you context around how your product fits into their broader workflow.</li><li>Usability observation lets you catch friction points, confusion, and unintended workarounds.</li></ul><p>What people <em>say</em> they do and what they <em>actually</em> do are often very different observation bridges that gap.</p><p><strong>Use when:</strong> You need behavioral insight or are testing prototypes and flows.</p><h4>Analytics &amp; Data Analysis</h4><p>Quantitative tools like Google Analytics, Mixpanel, or product analytics platforms like Amplitude help you track:</p><ul><li>Feature adoption</li><li>Drop-off points</li><li>Time on task</li><li>Retention cohorts</li><li>Conversion funnels</li></ul><p>Data can confirm patterns you suspect and highlight new ones you weren’t looking for. But remember, data tells you what is happening, not why. Combine it with qualitative research for the full picture.</p><p><strong>Use when:</strong> You want to prioritize or validate based on usage patterns and hard numbers.</p><h4>Web3-Specific Metrics &amp; Analytics</h4><p>For Web3, traditional tools aren’t enough. Instead, use:</p><ul><li>Blockchain Explorers (e.g., Etherscan, Polygonscan): Track transaction volume and contract interactions.</li><li>Smart Contract Analytics (e.g., Dune Analytics, The Graph): Monitor contract events and user movement within the dApp.</li><li>Decentralized Analytics (e.g., Nansen): Measure retention cohorts, feature adoption, and user behavior on-chain.</li></ul><p>Use when: Validating assumption, prioritizing features, and measuring performance</p><h4>Persona Development</h4><p>Personas are fictional but research-based profiles of different user types who interact with your product.</p><p>A good persona includes:</p><ul><li>Demographics and job role</li><li>Goals and frustrations</li><li>Behaviors and habits</li><li>Technology use</li><li>Environmental or emotional context</li></ul><p>Personas help teams stay aligned around <em>real people</em>, not vague “users.” They make empathy scalable, especially in cross-functional teams.</p><p><strong>Use when: </strong>You want to ground product strategy in user context and guide design and messaging decisions.</p><h4>User Journey Mapping</h4><p>A user journey map traces the full path a user takes when trying to accomplish something from awareness to engagement to completion (and sometimes churn).</p><p>It includes:</p><ul><li>Steps they take</li><li>Emotions they feel</li><li>Pain points they encounter</li><li>Opportunities for delight</li></ul><p>Journey maps are incredibly useful for spotting gaps, delays, or mismatched expectations across the experience.</p><p><strong>Use when:</strong> You want to improve flows, redesign onboarding, or identify moments where users fall off or lose trust.</p><h3>Tools Every PM Should Know (And Actually Use)</h3><p>You don’t have to run every research session yourself, but you should understand the tools that shape great product decisions.</p><p>These frameworks will help you think like a user, even when you’re deep in roadmap or execution mode:</p><h4><strong>Empathy Maps</strong></h4><p>“What is our user thinking, feeling, hearing, seeing, saying, doing?”</p><p>Empathy maps help you move beyond functional requirements and into the emotional and situational reality of your users.</p><p>Use them to align teams on who you’re building for and what truly matters to them.</p><h4><strong>User Personas</strong></h4><p>These are fictional characters, but based on real data.</p><p>A strong persona includes:</p><ul><li>Demographics (job title, industry, role)</li><li>Motivations (why they use your product)</li><li>Pain points (what gets in their way)</li><li>Context (where, when, how they use your product)</li></ul><p>Personas helps teams design with empathy, not guesswork.</p><h4><strong>Journey Maps</strong></h4><p>Journey maps lay out the full experience a user goes through from awareness to action across every touchpoint.</p><p>They visualize:</p><ul><li>What are users trying to do</li><li>Where they succeed or get blocked</li><li>What they feel along the way</li></ul><p>This helps uncover gaps, inconsistencies, and friction that aren’t obvious from inside the product.</p><h4><strong>User Stories</strong></h4><p>Instead of writing requirements as static tasks (“Add an export button”), user stories bring context to the request:</p><p>“As a marketing lead, I want to export a weekly report so I can share campaign results with my team.”</p><p>That one sentence helps clarify:</p><ul><li>Who the feature is for</li><li>Why it matters</li><li>What outcome it should enable</li></ul><p>It’s a small shift, but it changes how you think about building the right thing.</p><h3>Real-World Examples of Products Built Around User Needs</h3><h4><strong>Slack</strong></h4><p>Slack didn’t just build a team chat. It solved the chaos of scattered communication by integrating messaging, file sharing, and app connections into a unified, searchable workspace.</p><h4><strong>Uber</strong></h4><p>Uber didn’t just digitize taxis. It tackled core needs like reliable transportation, quick access, and transparent pricing. The result? A seamless, real-time network with low friction.</p><h4><strong>Airbnb</strong></h4><p>Airbnb focused on a different kind of user: travelers seeking affordable, authentic, and personalized stays. It matched hosts with guests, creating a new market for immersive travel experiences.</p><p>In each case, success came from solving deep, often unspoken needs, not just adding features.</p><h3>How to Build Products That Actually Meet User Needs</h3><p>Understanding user needs is only half the battle. The real challenge is consistently building products that meet those needs at the right time, in the right way, and for the right audience.</p><p>This isn’t a one-time effort. It’s an ongoing process of discovery, prioritization, validation, and iteration. Here’s how strong product teams put user needs at the center of everything they do:</p><h4>Start with Market Research and Persona Development</h4><p>Before you write a single line of code, you need clarity on who you’re building for and what they’re trying to achieve.</p><ul><li>Market Research helps you understand the industry landscape: what’s trending, what’s broken, and where the opportunity lies.</li><li>Competitor Analysis reveals what users expect and what they’re still missing.</li><li>User Personas turn abstract user segments into vivid profiles. A good persona goes beyond job title. It includes goals, frustrations, context, and priorities. For example: (i) A project manager might care about task visibility and real-time updates. (ii) A C-level executive might prioritize reporting, KPIs, and business outcomes.</li></ul><p>These personas help you design with empathy and keep your team aligned around real people, not assumptions.</p><h4>Interview Users and Collect Feedback Continuously</h4><p>Surveys are great for scale, but conversations uncover context. Talking directly to users, whether through interviews, user testing, or customer support reviews, is one of the best ways to understand their pain points.</p><ul><li>Ask open-ended questions like: (i)“What’s the most frustrating part of your workflow right now?” (ii)“Tell me about the last time this product helped (or failed) you.”</li><li>Go beyond feature requests. Probe for problems, not just solutions.</li></ul><p>And remember: feedback should never stop. Your users change, your product evolves, and new challenges will always surface.</p><h4>Prioritize Features Based on Value, Not Volume</h4><p>Once you’ve collected ideas, it’s tempting to start building everything. But that leads to bloat, not value.</p><p>Feature prioritization helps you focus on what actually moves the needle for users <em>and</em> the business.</p><p>Evaluate each idea based on:</p><ul><li>Impact on the User</li><li>Effort and technical complexity</li><li>Alignment with strategic goals</li></ul><p>Use frameworks like <strong>RICE</strong> (Reach, Impact, Confidence, Effort), <strong>MoSCoW</strong> (Must have, Should have, Could have and Won’t have), or a simple <strong>value–effort matrices</strong> to make your roadmap a strategy document, not just a backlog.</p><h4><strong>Prototype, Test, and Learn Early and Often</strong></h4><p>Building a product shouldn’t start with your engineering team. It should start with a prototype, a lightweight version of your solution that you can test before writing full code.</p><ul><li>Tools like Figma, InVision, or even hand-drawn wireframes let you gather feedback on ideas quickly.</li><li>User testing with even 5–10 people can reveal major usability flaws or confusing flows before you invest months in development.</li></ul><p>This process helps de-risk your product decisions and align your features with <em>real behavior</em>, not just opinions.</p><h4><strong>Use Analytics to Make Data-Driven Decisions</strong></h4><p>Once your product is live, quantitative data becomes your best friend.</p><ul><li>Track usage patterns: What features are used most? Where do users drop off?</li><li>Watch cohorts over time: Are new users adopting faster? Are they retaining longer?</li></ul><p>This kind of data helps you understand what’s working, what’s being ignored, and where you need to double down or rethink entirely.</p><p>But always pair data with qualitative feedback. Numbers tell you <em>what’s happening, </em>not always <em>why</em>.</p><h4><strong>Maintain a Living Roadmap and Run Regular Product Reviews</strong></h4><p>Great products aren’t “set and forget.” They evolve constantly based on new feedback, strategy changes, and market shifts.</p><ul><li>Regular product reviews let you reflect on progress, check alignment, and identify blind spots.</li><li>A living roadmap ensures your team stays focused not just on what’s next but on <em>why it matters</em>.</li></ul><p>Make sure your roadmap reflects user needs, not just stakeholder requests. Revisit it quarterly at minimum.</p><h3>Why Ideas and User Needs Both Matter in Product Management</h3><p>It’s easy to think of ideas and user needs as competing forces: one creative and instinctual, the other grounded and research-driven. But the truth is, great products require both.</p><p>Ideas give you energy, direction, and innovation. User needs give you focus, clarity, and validation. Balancing the two is what separates a feature-packed product from a user-loved one.</p><p>Here’s why understanding both is essential to any product leader’s toolkit:</p><h4><strong>Customer Satisfaction</strong></h4><p>When you address real user needs, not just surface-level wants, you deliver outcomes that matter. Users feel seen, supported, and empowered. And satisfied users don’t just stick around; they tell others. They become advocates.</p><p>A product that delivers emotional and functional satisfaction becomes part of a user’s workflow or daily life.</p><h4><strong>Market Relevance</strong></h4><p>User needs evolve. New tools emerge. Competitors adapt.</p><p>The only way to stay relevant in a fast-moving market is to build for changing needs, not static ideas.</p><p>Product managers who stay tuned into their users’ environments are better positioned to pivot, innovate, and lead.</p><h4><strong>Reduced Churn</strong></h4><p>When users leave, it’s rarely because of one missing feature; it’s usually because the product no longer meets their needs.</p><p>By continuously discovering and addressing those needs, you reduce the likelihood of churn and retain value over time.</p><p>Retention isn’t about loyalty; it’s about continued alignment.</p><h4><strong>Stronger Brand Reputation</strong></h4><p>Brands are built on consistent experiences.</p><p>When a product consistently solves meaningful problems and delivers value, it creates trust. That trust turns into a reputation, and a reputation turns into market advantage.</p><p>In crowded categories, this is how you stand out.</p><h4><strong>Smarter Iteration</strong></h4><p>Ideas spark iteration, but user needs guide it.</p><p>Regular feedback loops ensure that what you improve is actually relevant to users.</p><p>Instead of chasing perfection, you build in public, learn fast, and make your product better with every release.</p><p>This is how great teams stay lean, strategic, and user-centered.</p><p>As product managers, it’s tempting to chase shiny ideas, especially when they come from stakeholders or competitors.</p><p>But real product leadership lies in the ability to filter signal from noise. To dig beneath the surface. To find the actual need, then solve it better than anyone else. Because when you build for needs, not just ideas, you don’t just ship features. You ship impact.</p><p>These personas help you design with empathy and keep your team aligned around real people, not assumptions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f9dcbe78c7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Smart Contracts Vulnerabilities — Reentrancy]]></title>
            <link>https://medium.com/web3-writers-guild/smart-contracts-vulnerabilities-reentrancy-3d5f30dbc3b2?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d5f30dbc3b2</guid>
            <category><![CDATA[solidity]]></category>
            <category><![CDATA[smart-contract-security]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Sun, 26 Nov 2023 21:10:29 GMT</pubDate>
            <atom:updated>2023-11-26T21:10:29.785Z</atom:updated>
            <content:encoded><![CDATA[<h3>Smart Contracts Vulnerabilities — Reentrancy</h3><figure><img alt="banner" src="https://cdn-images-1.medium.com/max/1024/1*vicpZ-nMR12gf8qYp50JoA.png" /></figure><h3>Introduction</h3><p>Solidity is one of the most popular high-level programming languages used to write smart contracts to EVM(Ethereum Virtual Machine) compatible blockchains such as Ethereum. Smart contracts on the other hand are self-executing agreements with the terms of the agreement written directly into codes and essentially stored on the blockchain. In web3, a smart contract serves as the backend for your decentralized application (Dapp). Unlike web2, the application can be loosely coupled which means that the different components of the application are not tightly dependent on one another. This allows for greater flexibility and easier maintenance of the application. For example, if one component of the application needs to be updated or replaced, it can be done without affecting other components of the application. This is not so for Smart contracts, they are immutable which means they can not be altered once deployed to the blockchain although this is not entirely true. You can look into <a href="https://docs.openzeppelin.com/upgrades-plugins/1.x/proxies">proxy smart contracts</a> for further explanation. Also, smart contracts can handle and transfer assets such as cryptocurrencies, tokens, and other digital values. This stated attribute makes a smart contract very valuable. Imagine having such smart contracts with bugs and other vulnerabilities, the assets are gone to malicious attackers. This highlights the critical importance of security during the development of smart contracts, as any security issues can result in real financial losses.</p><p>Furthermore, the immutable nature of smart contracts means that once they are deployed, any security issues or vulnerabilities cannot be easily fixed without significant effort. Therefore, developers need to take the necessary measures to ensure the security and reliability of their smart contract code before deploying it on the blockchain.</p><p>In this series, I will be sharing with you some smart contract vulnerabilities and how to avoid them while writing your smart contracts.</p><p>In the first part of this series, we will be explaining reentrancy attacks and how to prevent them.</p><h3>Reentrancy Attack</h3><p>The reentrancy attack is one of the most popular attacks in the DeFi system. It simply happens when a smart contract makes an external call to an untrusted smart contract. This can happen when a smart contract sends ether to another smart contract using the call function. When a call function is used to make an external call to another smart contract without specifying any function to call it essentially triggers a fallback function in the smart contract being called. It is also important to note that it is compulsory for a smart contract to have either a fallback function marked payable or receive function marked payable before it can receive ether. A fallback function can have pieces of code written in it. Hence, a malicious attacker can use the fallback function to make multiple calls to any of your functions. An example is your withdrawal function until all the money in your smart contract is finished. Here is an example of this.</p><pre><br>// SPDX-License-Identifier: GPL-3.0<br>pragma solidity 0.8.0;<br><br>contract Store {<br> mapping(address =&gt; uint) public balances;<br><br> function deposit() public payable {<br>  balances[msg.sender] += msg.value;<br> }<br><br> function withdraw() public payable {<br>  uint bal = balances[msg.sender];<br>  require(bal &gt; 0);<br>  (bool sent, ) = msg.sender.call{value: bal}(&quot;&quot;);<br><br>  require(sent, &quot;Transaction failed&quot;);<br>  <br>  balances[msg.sender] = 0;<br> }<br>}</pre><p>The code above is of a smart contract named Store. It employs a mapping data structure to keep track of the balance of each user in the smart contract. It has two functions namely deposit and withdraw; the deposit function increments the balance of each user when called while the withdraw function is used to withdraw the user’s balance. You might have noticed where the mistake is in the withdraw function. Let us take a look at another contract to give a further explanation;</p><pre>// SPDX-License-Identifier: GPL-3.0<br>pragma solidity 0.8.0;<br><br>contract Attack {<br> <br>Store public store;<br> constructor(address _storeAddress) {<br>  store = Store(_storeAddress);<br>     }<br><br> fallback() external payable {<br>  if(address(store).balance &gt;= 1 ether) {<br>   store.withdraw();<br>          }<br> }<br><br> function attack() external payable {<br>  require(msg.value &gt;= 1 ether);<br>  store.deposit{value: 1 ether}();<br>  store.withdraw();<br> }<br>}</pre><p>The contract above is named Attack. It is used to attack the previous contract. When reading through the contract you will see that the Attack contract accepts the Store contract address. It does so to call some external functions on the Store contract such as deposit and withdraw. In the attack function, it calls the deposit function of the Store contract to deposit 1 ether into the contract since Store requires that you have above 0 ether before you can make a withdrawal. The issue with the withdraw function in the Store contract is that it allows users to make withdrawals first before setting their balance to zero which leads to a big flaw in the contract. An attacker can call the withdraw function multiple times to withdraw more than their balance in the contract because the function requires you to have above zero balance which the user still has as long as the function does not hit the state variable that is the balance of the user in the contract. The attack function calls the withdraw function in the Store contract immediately which in turn triggers the fallback function. The fallback function calls the withdraw function which calls the fallback function again. This pattern repeats itself until no money is found in the Store contract.</p><h3>How to Protect Smart Contracts Against Reentrancy Attack</h3><p>There are a few measures to take when trying to protect smart contracts against a reentrancy attack. Here are a few;</p><ul><li><strong>Using Solidity’s Check-Effect-Interaction pattern:</strong></li></ul><p>Solidity’s Check-Effect-Interaction (CEI) pattern is a programming paradigm used to enhance the security and efficiency of smart contract development. The pattern consists of three steps: checking inputs and conditions, updating the state of the contract if the inputs and conditions are valid, and finally, interacting with external contracts or the blockchain if required.</p><p>In the first step, the input data and conditions are checked to ensure that they meet the requirements for the intended action. This includes checking for things like valid addresses, sufficient balances, and correct signatures, among other conditions. This step helps to prevent errors and security vulnerabilities by ensuring that only valid inputs are processed.</p><p>In the second step, the state of the contract is updated based on the inputs and conditions. This includes updating balances and performing other state-changing actions. This step is critical to ensuring the proper functioning of the smart contract and maintaining the integrity of the blockchain.</p><p>In the final step, the contract interacts with external contracts or the blockchain to complete the desired action. This includes sending tokens, invoking functions on other contracts, or writing data to the blockchain. This step is necessary for the smart contract to interact with other contracts or to make changes to the state of the blockchain.</p><p>In this case, we will have the withdraw function looking like this;</p><pre>function withdraw() public payable {<br>  uint bal = balances[msg.sender];<br>  require(bal &gt;= 0);<br><br>  balance[msg.sender] = 0;<br><br>  (bool sent, ) = msg.sender.call{value: bal}(&quot;&quot;);<br><br>  require(sent, &quot;Transaction failed&quot;)<br> }</pre><p>Using the CEI pattern can help developers write more secure and efficient smart contracts by ensuring that inputs and conditions are validated before any state changes are made and that interactions with external contracts or the blockchain are performed only after the contract state has been updated correctly. This pattern has become a best practice for writing Solidity smart contracts and is widely used by developers to ensure the safety and reliability of their code.</p><ul><li><strong>Using OpenZeppelin ReentrancyGuard contract:</strong></li></ul><p>You can visit the <a href="https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol">OpenZeppelin ReentrancyGuard</a> to understand the contract better. You inherit the ReentrancyGuard contract into your smart contract and make use of the nonReentrant modifier on your function. Here is an example;</p><pre>// SPDX-License-Identifier: GPL-3.0<br>pragma solidity 0.8.0;<br><br>import &quot;@openzeppelin/contracts/security/ReentrancyGuard.sol&quot;;<br><br>contract Store is ReentrancyGuard {<br> mapping(address =&gt; uint) public balances;<br><br> function deposit() public payable {<br>  balances[msg.sender] += msg.value;<br> }<br><br> function withdraw() public payable nonReentrant {<br>  uint bal = balances[msg.sender];<br>  require(bal &gt;= 0);<br>  (bool sent, ) = msg.sender.call{value: bal}(&quot;&quot;);<br><br>  require(sent, &quot;Transaction failed&quot;);<br>  <br>  balances[msg.sender] = 0;<br> }<br>}</pre><p>The nonReentrant modifier is added to ensure that the function can only be called once and cannot be re-entered by an attacker to drain the contract&#39;s funds. Using the ReentrancyGuard contract and the nonReentrant modifier, one can add an extra layer of security to one’s Solidity smart contracts and protect them from reentrancy attacks.</p><ul><li><strong>Using bool to lock the function until it is done running:</strong></li></ul><p>This is partially similar to the OpenZeppelin ReentrancyGuard contract discussed above. The concept is to prevent reentrancy attacks by ensuring that a function cannot be called again until it has completed its previous execution. If the attacker tries to run the function multiple times at once, it will not work. Here is an example below;</p><pre>// SPDX-License-Identifier: GPL-3.0<br>pragma solidity 0.8.0;<br><br>contract Store {<br> bool internal locked;<br> modifier nonReentrant () {<br>  require(!locked, &quot;Not Permitted&quot;);<br>  locked = true;<br>  _;<br>  locked = false;  //this executes after the function is done<br>}<br><br> mapping(address =&gt; uint) public balances;<br><br> function deposit() public payable {<br>  balances[msg.sender] += msg.value;<br> }<br><br> function withdraw() public payable nonReentrant {<br>  uint bal = balances[msg.sender];<br>  require(bal &gt;= 0);<br>  (bool sent, ) = msg.sender.call{value: bal}(&quot;&quot;);<br><br>  require(sent, &quot;Transaction failed&quot;);<br>  <br>  balances[msg.sender] = 0;<br> }<br>}</pre><p>The nonReentrant modifier works by setting a boolean flag called locked to true before the function is executed. If the flag is already set to true, the function will revert and the user will not be able to execute it again. Once the function is complete, the flag is set back to false, allowing the function to be called again.</p><h3>Conclusion</h3><p>The reentrancy attack poses a significant threat to the security and integrity of smart contracts, particularly in the DeFi ecosystem. By exploiting the fallback function triggered during external contract calls, attackers can manipulate contract states, drain funds, and cause unintended behaviors.</p><p>Preventing reentrancy attacks requires diligent coding practices and adherence to security best practices. Implementing the “Checks-Effects-Interactions” pattern, employing reentrancy guard mechanisms, and conducting thorough testing and security audits are crucial steps to mitigate the risks.</p><p>As the popularity of decentralized applications and DeFi systems continues to grow, it becomes imperative for smart contract developers to be aware of the reentrancy attack and take proactive measures to fortify their contracts. By prioritizing security and employing robust defense strategies, we can build a safer and more trustworthy decentralized financial landscape.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d5f30dbc3b2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/web3-writers-guild/smart-contracts-vulnerabilities-reentrancy-3d5f30dbc3b2">Smart Contracts Vulnerabilities — Reentrancy</a> was originally published in <a href="https://medium.com/web3-writers-guild">Web3 Writers Guild</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cairo Programming Language: An Introduction to Variables and Basics]]></title>
            <link>https://medium.com/web3-writers-guild/cairo-programming-language-an-introduction-to-variables-and-basics-8162f4764a42?source=rss-3bfa2b97db79------2</link>
            <guid isPermaLink="false">https://medium.com/p/8162f4764a42</guid>
            <category><![CDATA[cairo-lang]]></category>
            <category><![CDATA[starknet]]></category>
            <dc:creator><![CDATA[Samuel Babalola]]></dc:creator>
            <pubDate>Mon, 13 Nov 2023 17:52:01 GMT</pubDate>
            <atom:updated>2023-11-14T14:40:44.703Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vdBdYR8bMudQ5ThtNVji2A.png" /></figure><h3>Introduction</h3><p>Cairo is a high-level programming language used for writing provable programs on Starknet. Provable program in the sense that one party can prove to another party that a certain computation was executed correctly without needing the party to re-execute the same program. It is also a Turing complete program which means it can be used to perform any computation that can be described algorithmically. Cairo has the necessary features to express any computable function or algorithm, and manipulation of data in a way that allows for the execution of any algorithm. Cairo is inspired by Rust and has a similar syntax to that of the Rust programming language.</p><p>The earlier version of Cairo (Cairo 0) is compiled directly to Casm (Cairo Assembly) which had some faults such as;</p><ul><li>Only valid statements can be proven in Cairo. It was impossible to prove an invalid code like assert 0 = 1 , this is a valid Cairo instruction that cannot be proven, as it translates to polynomial constraints that are not satisfiable.</li><li>The sequencer is not being compensated after work; sequencers in L2 are meant to take their execution fee after a transaction has been executed and also add the transaction into the block even if the transaction fails during execution. Still, it was not so with Cairo 0 which could also lead to a DOS attack on the sequencer. The sequencer can only predict that a transaction will fail if it does the work.</li><li>Distinguishing between an invalid transaction and the transactions that the sequencer does not accept would be impossible.</li></ul><p>An extra layer between the user code (Cairo) and what is proven (CASM) had to be added to avoid these. The extra layer added is called Sierra (<strong>S</strong>afe <strong>I</strong>ntermediate <strong>R</strong>epresent<strong>a</strong>tion); this layer allows us to ensure that all transactions are eventually provable. So, the current version of Cairo is first converted to Sierra, then compiled to a subset of Casm known as safe Casm. This guarantees that the user code is always provable.</p><p>Also, Cairo uses an immutable memory model. This means that after a value has been written into a memory cell it cannot be overwritten but can only be read from. Cairo made provision for developers to work around this constraint but it does not fully simulate mutability. In this article, we will be going through the introductory phase of this series. In the subsequent articles on Cairo, we would dive deep into more concepts in the Cairo programming language.</p><h3>Installation of Cairo</h3><p>You can install Cairo by just downloading Scarb. Scarb comes with the Cairo compiler and Cairo language server bundled together. Scarb is also a Cairo package manager; it helps build Cairo code (either pure cairo or Starknet contract). As a package manager, it helps handle multiple dependencies and a robust codebase.</p><p>To download scarb you can look into the scarb documentation <a href="https://docs.swmansion.com/scarb/download.html">here</a>.</p><p>Here are some of the Scarb commands you will need to get things running for your Cairo project;</p><ul><li>scarb new : it is used to spin up a new Cairo project.</li><li>scarb build : it is used to build your cairo code to generate the compiled Sierra code.</li><li>scarb test : it is used to run tests.</li><li>scarb run : it is used to call scripts in the Scarb.toml .</li></ul><p>To write a Starknet contract you will need other tools such as Katana to create a local test node, Starknet Foundry to write the test for the contract, and Starkli as a CLI tool for interacting with the Starknet network. For the scope of this article, installing scarb will do. In the next section, we will be looking into variables in Cairo.</p><h3>Variables in Cairo</h3><p>Variable is a common concept to every programming language; It is a container that allows one to store and manage values in a computer’s memory. However, in Cairo, the concept of variables is a bit different. Cairo uses an immutable memory model, which means that once a memory cell has been written to it can not be overwritten but be read from only.</p><p>So, breaking this down it means that whenever you assign a specific value to a variable name in Cairo, you will not be able to assign a new value to it, this makes your code more secure. You do not have to worry about any errors due to value changes in the code. Though Cairo works with an immutable memory model there is a feature that comes with the program that gives the developer the privilege to make the variable mutable if the developer chooses to.</p><p>Below is a code example;</p><pre>use debug::PrintTrait;<br>fn main() {<br>    let x = 2;<br>    x.print();<br>    x = 13;<br>    x.print();<br>}</pre><p>The following is the error that comes out of the terminal after running scarb cairo-run</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tOMWKbYg2wH3Wt68syKVCA.png" /></figure><p>The error in the image above shows that you can not assign an immutable variable.</p><p>You cannot just assign another value to a variable that has a value already in Cairo unless you specify that the specific variable should be mutable. The way it works is that you add the mut keyword before the variable name.</p><p>Below is an example that you can find;</p><pre>use debug::PrintTrait;<br>fn main() {<br>    let mut x = 2;<br>    x.print();<br>    x = 13;<br>    x.print();<br>}</pre><p>This is what your terminal should look like after running the scarb cairo-run command;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8Wwmg75jVMo1lUIr.png" /></figure><p>This shows that your code compiles successfully.</p><p>Under the hood, Cairo does not change what has already been assigned to a memory cell, as we said earlier it is immutable but it can change the memory address where the variable points to. Variable mutation is implemented as syntactic sugar, it translates the mutation operations into steps similar to variable shadowing. The key distinction is that, at the Cairo level, the variable is not redeclared, maintaining its type immutability.</p><h3>Constant in Cairo</h3><p>The concept of constant is similar to that of variable in Cairo but with a few differences. Unlike variable in Cairo which has a mutable option, Constant in Cairo does not have a mutable option. Constant by default is always immutable. Also, you cannot use the mut and the let keyword in a constant statement. When declaring a constant there are a few things to do; Firstly, add the const keyword to the variable, and secondly add the data type of the variable in front of the variable.</p><p>Here is an example;</p><pre>const ONE_YEAR_SUBSCRIPTION_PLAN: u32 = 365; // Number of days</pre><p>The above example describes what a constant variable looks like.</p><p>The naming convention in Cairo for constants is that the words must be in uppercase with an underscore between the words. Also, looking at the example you can see how comments are written in Cairo language with the double forward slash // syntax.</p><p>Constants in Cairo are set to a specific, fixed value that is directly written in the code and does not change during the execution of the program. The values can be determined at compile time and are not computed or derived during runtime.</p><p>It is also good to note some other properties and use cases of constant in Cairo;</p><ol><li>Declared in Global Scope: Constants are typically declared in global scope, meaning they are accessible from any part of the code. This makes them useful for values that many parts of the code need to know about without having to pass the values explicitly.</li><li>Useful for Shared Information: Constants are valuable for values that multiple parts of the program might need to know about. For example, constants can represent universal values or parameters that are shared across different modules or components.</li><li>Valid for the Entire Program Runtime: Constants retain their values for the entire duration of the program within the scope in which they were declared. This provides a consistent and unchanging reference for the specified value throughout the program’s execution.</li><li>Application in Application Domain: Constants are particularly useful for values related to the application domain, such as rules, limits, or properties that remain constant across the program’s execution. Examples are interest rate, maximum loan amount, and exam passing score.</li></ol><p>Constants enhance code readability and maintainability by providing named, unchanging values for widely used parameters or settings. They centralize important values, reducing the risk of errors, improving consistency, and making it easier to update or modify shared values across the codebase.</p><h3>Shadowing in Cairo</h3><p>What shadowing does is that it helps you re-assign another value to an already initialized variable without using the mut keyword which also allows you to use another data type on the variable different from the one previously in use. We would break everything down;</p><p>When you already have a value assigned to a variable, the shadowing feature allows you to redeclare the variable and re-initialize the variable by using the let keyword. When this happens the compiler picks the value of the most recent one and makes use of that whenever the variable is being used anywhere else in the code. This continues until that variable is overshadowed or has gone past the scope in which the shadowing occurs. It is also good to note that the variables are still immutable after they have gone through the shadowing process.</p><p>When a variable undergoes the shadowing process it is also equivalent to making a variable mutable in Cairo low-level. Regardless, there are still some differences between making a variable mutable and shadowing a variable; You cannot change the variable data type of a variable by just making it mutable. Redeclaring a variable by adding the let keyword can allow you to add a new data type cause at that point you declare a new variable but with the same name.</p><p>Here is an example;</p><pre>use debug::PrintTrait;<br><br>fn main() {<br>    let  count: felt252 = &#39;hello&#39;;<br>    &#39;Initial count value is:&#39;.print();<br>    count.print();<br><br>    // Shadowing with a different type<br>    let count: u8 = 5;<br>    &#39;Shadowed count with integer:&#39;.print();<br>    count.print();<br><br>    // Inner scope with its own count<br>    {<br>        let count: u8 = count * 2; // Shadows the outer &#39;count&#39; in this inner scope<br>        &#39;Inner scope count value is:&#39;.print();<br>        count.print();<br>    }<br><br>    // &#39;count&#39; in the outer scope remains unchanged<br>    &#39;Outer scope count value is:&#39;.print();<br>    count.print();<br>}</pre><p>This is what your terminal should look like after running scarb cairo-run</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rBHsKegnij2YdQsq.png" /></figure><p>The above code describes many of the things we talked about like changing data type and assigning another value to a variable. I know that you are seeing some things we have not spoken about like the data types. We will talk about some of the other common cairo programming concepts in this series.</p><h3>Conclusion</h3><p>Variables lie at the heart of any programming language, and Cairo’s approach is both unique and powerful. Embracing the concept of immutability in memory while providing the flexibility of variable mutation, Cairo strikes a delicate balance. Through our exploration of Cairo’s variables, we’ve witnessed how syntactic sugar and the Sierra layer contribute to robust, provable computations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8162f4764a42" width="1" height="1" alt=""><hr><p><a href="https://medium.com/web3-writers-guild/cairo-programming-language-an-introduction-to-variables-and-basics-8162f4764a42">Cairo Programming Language: An Introduction to Variables and Basics</a> was originally published in <a href="https://medium.com/web3-writers-guild">Web3 Writers Guild</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>