<?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 Andre Powers on Medium]]></title>
        <description><![CDATA[Stories by Andre Powers on Medium]]></description>
        <link>https://medium.com/@product-obsessed?source=rss-eaca3aa82ebb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*T6KuiJjsTPf3H39dtn-47Q.png</url>
            <title>Stories by Andre Powers on Medium</title>
            <link>https://medium.com/@product-obsessed?source=rss-eaca3aa82ebb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 04:28:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@product-obsessed/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[2023: The Year to Finally Retire “Painted Door” User Tests]]></title>
            <link>https://product-obsessed.medium.com/2023-the-year-to-finally-retire-painted-door-user-tests-b3053bc145b6?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3053bc145b6</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[strategy]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[tech]]></category>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Mon, 24 Apr 2023 13:46:53 GMT</pubDate>
            <atom:updated>2023-04-24T13:46:53.262Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/275/1*axzxO1bBqyG65RMrUI2Wrg.png" /><figcaption>Don’t run your users into walls.</figcaption></figure><h3>How to Collect Insights with In‑Product Surveys Instead</h3><p>Painted doors or “fake” doors have long been a popular way to get feedback from users and customers and test new ideas or assumptions about new features in software products. Classic examples of painted doors include buttons to activate features that don’t yet exist, or allowing users to add items to a checkout cart that are not yet for sale. Like a painted image of a door on a wall of a building, the idea is to make a user think they can access something that is ultimately not available to them to see if they would use it if it was available.</p><p>Proponents like that these tests seemingly provide a more honest reflection of a user’s <a href="https://sprig.com/templates/gauge-feature-satisfaction">response to a new feature or product</a> than a response to a survey question, since the user took an action instead of just saying they would take an action. But this “honesty” comes at a cost. By not asking them directly for their feedback — making it clear you value them — you miss out on building a bond that could provide more and longer-term insights on how to create value for your customers. Plus, when properly designed, <a href="https://sprig.com/surveys">in-context surveys</a> can be not only more insightful, but faster and cheaper to launch.</p><p>Let’s explore why you should retire painted door tests from your <a href="https://sprig.com/blog/modern-product-tech-stack-2">product manager toolbox</a>.</p><h3>What are in‑product surveys?</h3><p><a href="https://sprig.com/surveys">In-product surveys</a> are short surveys (often just a single question) with the goal of quickly getting feedback from users and customers. While they are most known for measuring things like <a href="https://sprig.com/templates/measure-net-promoter-score">net promoter score (NPS)</a> or<a href="https://sprig.com/templates/measure-customer-satisfaction"> customer satisfaction (CSAT)</a>, surveys are great at rapidly answering questions of viability, desirability, or other assumptions about new feature ideas.</p><p>When you launch an in-product survey to validate an idea, you build conviction and reduce leaps of faith about the appetite or ability of users and customers to adopt a new feature or product.</p><p>They can be especially effective when used in-product, in-context. For example, when a user reaches a two-factor authentication (2FA) screen to provide an SMS code while logging into your application, you might trigger an in-product survey asking if there are other 2FA methods the user would prefer to use. The user can submit a response with a single click taking only a second, and you’ll get valuable feedback on what 2FA methods are preferred by your users.</p><h3>The problem with painted doors</h3><p>You could achieve a similar insight in the 2FA example using a painted door, for example by having a sidebar with buttons that provide other 2FA options to the user. When the user selects one, you record their click and provide some form of “coming soon” message to the user. You’ll get the same information with this method, but there is one obvious downside: you tricked your user!</p><p>The experience of a painted door leads to an element of disappointment. You make the user believe they have the ability to do something they can’t, and they only find that out after attempting it. The disappointment is then compounded by the realization that they were surreptitiously fooled into providing information to you. It’s hard to see how these feelings could constitute a positive experience. Imagine encountering an actual painted door in real life. You want to make use of the door, only to walk into a wall (ouch), and realize someone has fooled you. How many of us would describe that as a good experience?</p><p>The in-product survey by contrast is a much more transparent approach that shows your users that you are interested in their opinion, and view them as a partner in your product. It builds trust by engaging the user.</p><p>Building that trust pays dividends down the road. Not just in referrals, but a willingness to share their time in more intensive feedback channels like customer interviews and user testing sessions that generate more insights about valuable opportunities.</p><p>In addition, you can give users an open-ended option in the survey to provide context. This kind of context is rare in painted door tests where you’re more likely to just see what users did or chose, but not why they did.</p><h3>Faster, cheaper, and easier to launch.</h3><p>Painted doors are often promoted as quick and easy ways to get feedback, but they will almost always require more time and effort than a in-product survey. Assuming you have integrated a best-in-class tool like <a href="https://sprig.com/">Sprig</a>, precisely targeted survey experiences can be launched almost immediately, without any development work required. You can use any custom event in your application as a trigger to target the survey at precise moments, and you can filter down who sees the survey by using any user attributes you track in your application. Again, no dev work needed.</p><p>Even the smallest painted door experience usually requires code, and if you are using sprint release cycles that means it’s unlikely the test is launched right away. You’ll also have to remember to deactivate the painted door experience. Getting the results of the test in front of stakeholders will probably also take longer since the data has to be gathered from the database manually, rather than immediately available in an easy-to-access dashboard.</p><h3>When painted doors are a good choice.</h3><p>There are certain questions where painted doors can be more effective than in-product surveys. There is a well known disconnect between indicating willingness to buy in a survey question and actual willingness to buy. Here, painted door tests can be a useful way to capture candid willingness to buy that might get obscured in a survey question, especially if the test includes providing payment information. Similarly, testing price points is tricky with surveys, since the user has a strong incentive to indicate a preference for the lowest option even if they would pay more. A painted door test with different price points would give a much more reliable indication of what users are willing to pay.</p><p>Even so, it’s still possible to reduce the need for painted doors even on questions of price elasticity or willingness to buy. Staying close to your customers with regular in-depth interviews to understand their needs thoroughly will give you the insight to make really good decisions on questions like these without the risks that come with painted door tests.</p><h3>A resolution for 2023</h3><p>Painted door tests have been a clever way to get users to reveal information about their preferences for many years. But the most successful product teams now focus on building close relationships with their customers to understand them using interviews, surveys, and user testing.</p><p>The deeper understanding built with in-context survey methods pays ongoing dividends to product teams by giving much more information about how to create value for users. That means they are better for the user <em>and</em> for the product team. In 2023, I hope to bump into fewer painted doors.</p><p><em>This post was a collaboration with the product insights platform </em><a href="http://www.sprig.com/"><em>Sprig</em></a><em>. The original post can be viewed </em><a href="https://sprig.com/blog/in-product-surveys-gauge-user-expectations"><em>here</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3053bc145b6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Does Your Product Manager Know What They are Doing?]]></title>
            <link>https://product-obsessed.medium.com/does-your-product-manager-know-what-they-are-doing-ea5c8d9ef54a?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea5c8d9ef54a</guid>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[founders]]></category>
            <category><![CDATA[strategy]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Tue, 18 Apr 2023 13:38:13 GMT</pubDate>
            <atom:updated>2026-06-04T23:31:10.014Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9_spZ1G_uULHFh6Ny80Zdw.jpeg" /><figcaption>A frustrated founder</figcaption></figure><h3>Why it’s so hard to create Product-Founder alignment and how to do it.</h3><p><em>This post was a collaboration with the product management platform </em><a href="http://www.delibr.com/"><em>Delibr</em></a><em>. Delibr ceased operations in 2026 and the product mentioned in this article is no longer available, although there are similar platforms like </em><a href="https://vistaly.com/"><em>Vistaly</em></a><em>.</em></p><p>As a “product-guy founder” turned professional product executive, I’ve been able to see just how pervasive misalignment of product teams and leadership teams can be. I think about these situations a lot because I can think from the founder’s perspective as well as the product manager’s. I try to think about how I would structure my own company’s product organization to avoid these kinds of costly misalignments.</p><p>For founders, nothing creates more anxiety than feeling like you hired the wrong product person, especially the critical first product hire. For PMs, being out of sync with higher-ups makes your job much less enjoyable.</p><p>The core of almost all misalignments between product managers and founders or executive leadership teams (ELTs) is a disconnect between the company objectives and the opportunities in the product to drive those objectives. Fortunately, product strategy methodology has developed ways to better align company objectives or outcomes with product outcomes that can be driven by product managers. These practices should become more widespread and I want to share some tips that I will likely use the next time I launch another startup.</p><h3>OKRs are a Good Start</h3><p>In some sense, product-ELT misalignment should be less of a problem than ever. Many companies make use of, in one way or another, the <a href="https://www.whatmatters.com/faqs/okr-meaning-definition-example">Objectives and Key Results</a> (OKR) framework for clearly defining and communicating company goals across the organization.</p><p>OKRs are designed to articulate in a clear way what the company needs to achieve in order to move forward. The objectives should be concrete and clearly defined, and the key results should logically indicate a success state of the objective and be numerically measurable to know if or how much the company has succeeded in reaching the objective. The point is to make it easy for the entire company to know what’s most important for the organization right now, and to align their work to achieving those objectives.</p><p>But even with OKRs product teams and executive teams can find themselves misaligned about what features or areas of the product the company should invest in. As software companies become increasingly “product-led,” this is obviously a big problem. And it usually comes down to a lack of a shared understanding of the opportunities to drive business outcomes from the product.</p><h3>Map Product Outcomes to Business Outcomes</h3><p>The simplest way to align the goals that a product manager can control (product outcomes) to the goals the business needs to achieve (business outcomes) is to map them. A company-wide goal like increasing revenue can be mapped to product outcomes like increasing the percentage of users who switch to a paid tier of the product, or increasing the number of paid features customers use. These are outcomes product managers can control to contribute to the company-wide goal of increasing revenue.</p><p>‍</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_aCwteL0IB8VQzHq.png" /></figure><p>‍</p><p>The harder part is figuring out which product outcome to focus on, because there must be an opportunity available to act on in order to drive the outcome. This is where things get complicated.</p><p>‍If you break down almost any product outcome you can think up (increase sign-ups, decrease returns, increase renewals, etc.) you will quickly realize that all product outcomes are essentially actions or behavior you want users to do with the product. But how do you get someone to do something you want? Unless it’s a loved one, you will almost certainly need some benefit to them taking the action. For software products, this likely means you need to solve some problem for the user or fulfill some need. That means our opportunities to get users to take the actions we want and drive our desired product outcomes are limited to the set of problems we can solve for them.</p><p>Features and products that don’t solve a problem for the user will not see the traction you need to achieve your outcome. And this is where product-ELT misalignment can rear its ugly head. If company leadership and product teams don’t agree on what needs are most important to users, they are not going to agree on what the product roadmap should be.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eTqEQUQVcJbtIbVZ.png" /></figure><p>The clear solution here is that PMs and the ELT need to share and exchange what they know about customer needs and how they believe they map to product outcomes, and ultimately business outcomes. But how?</p><h3>Use Opportunity Solution Trees to Share Understanding of the Customer</h3><p>Many of you reading this have already recognized the elements of the book <em>Continuous Discovery Habits</em> I’ve been dropping so far, and won’t be surprised that my recommendation is to use an <a href="https://www.delibr.com/post/guide-to-making-opportunity-solution-tree-come-to-life">Opportunity Solution Tree</a> (OST, sometimes called Opportunity Space ) to communicate the needs and pain points of customers to others. If you didn’t recognize terms like outcome mapping, <a href="https://www.amazon.com/Continuous-Discovery-Habits-Discover-Products/dp/1736633309">pick up a copy of the book</a> ASAP!</p><p>OSTs provide the full picture of how product teams can create value and contribute to company goals. They map needs and pain points of customers to product outcomes that in turn map to company goals and OKRs. They guide the ideas of potential features that could be added to the roadmap and help the selection of those ideas. My advice to founders and ELTs is to use OSTs to communicate the opportunities you see to drive outcomes to your product teams, especially new or first product hires.</p><p>‍</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jh6hEi0_mVxtB2dd.png" /></figure><p>‍</p><p>Oftentimes as founders, we feel an intuitive sense of what the customers of our company need that can be hard to articulate. In reality, what you know about your customers is not just intuition but a result of all the time you’ve spent with them: talking to them, pitching them, closing contracts with them. It’s important to remember that your PMs may not have all this understanding of the customer that you’ve accumulated. You need to document and communicate what you understand about customers to your product team.</p><p>Delibr’s OST feature is probably the best tool I’ve seen for maintaining OSTs. It’s great visually, but also does an excellent job of storing notes and documentation. Each node in the OST (outcomes, opportunities, solutions, and experiments) can be opened like a document with all notes, links, and other information right there in the node. The templates are fantastic for guiding documentation or scoping, so that, for example, a solution idea on the OST can contain all the requirements, scoping, user journeys, etc, for that feature.</p><p>You can start by simply jotting down a few notes about the pain points you believe are most common for your customers, these will be the opportunities on your OST. Try to provide as much context about them as possible. In Delibr, you can add notes directly to an opportunity node that the PM can reference as needed. If you don’t have recordings of interviews or sales calls that you’ve done, be sure to include notes about where this feedback came from.</p><p>From here, you should share the notes with your PM or product team, but then hash out product outcomes together with them. You’ll still do most of the driving here, since you will know more about the product than they do. But it’s important to give them a voice in identifying the product outcomes they will ultimately be responsible for delivering. Work together and discuss how different outcomes can tie back to the business outcomes you’ve set for the company.</p><p>Finally, sketch a few solution ideas with the team. If possible, go through the normal brainstorming process described in <em>Continuous Discovery Habits</em>. Discuss each idea and assumptions that jump out as you sketch each solution. This gets the PM involved in shaping solution ideas, so that you are not just assigning them stuff to work on. But the goal is still a few potential projects the PM or product team can start on right away. That helps get them going while they also start developing their own deeper understanding of customers.</p><p>You should explain why you think a certain opportunity or feature is a better candidate than another, but it’s important that the PM still does the work of learning more about the pain points you believe you’ve confirmed, by doing interviews, mapping out assumptions about solutions, and running tests on those assumptions (experiments). Founders don’t always make it to this level of customer discovery, but these are absolutely the things product managers should be doing.</p><h3>Stay Aligned</h3><p>The OST you come up with together with your PM is a starting point that transfers what you know about the customer to the PM. It starts everyone off with a shared understanding of the opportunities for the company to drive outcomes. It should remain as a focal point for the product roadmap as your PM learns more about customers than even you did.</p><p>As the objectives of the business change, the OST ensures alignment between ELT and Product. PMs use what they know about customers to come up with projects that tie back to product outcomes that contribute to the company’s OKRs. ELTs can follow the reasoning of the PM of what to prioritize against an opportunity space tree that contains what the company knows about customers. In this way, OSTs are not just a great way to get a new PM started, but to ensure ongoing alignment and impact.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea5c8d9ef54a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Translating from .then() to async/await]]></title>
            <link>https://product-obsessed.medium.com/translating-from-then-to-async-await-8bfc74baec08?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/8bfc74baec08</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-app-development]]></category>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Fri, 28 May 2021 11:24:47 GMT</pubDate>
            <atom:updated>2021-05-28T11:34:11.791Z</atom:updated>
            <content:encoded><![CDATA[<h3>Translating from .then() to async/await</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F4NnTap3gOhhlik1YEw%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2F4NnTap3gOhhlik1YEw&amp;image=https%3A%2F%2Fmedia3.giphy.com%2Fmedia%2F4NnTap3gOhhlik1YEw%2Fgiphy.gif%3Fcid%3D790b7611d672a6dbf8d9069d8807c9821e6435c1d1cc67a0%26rid%3Dgiphy.gif%26ct%3Dg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/feecbf237bc2b9b23887cab896737e75/href">https://medium.com/media/feecbf237bc2b9b23887cab896737e75/href</a></iframe><p>I recently published <a href="https://javascript.plainenglish.io/how-to-make-your-js-fetch-not-look-so-ugly-f45c89f8bc3a">a guide</a> on how to make <em>fetch()</em> calls in javascript using reusable functions for readability. The response to the article was huge, and many folks suggested implementing the asynchronous aspects of the code using <em>async</em> and <em>await</em> instead of .<em>then()</em> for various reasons.</p><p>While you could write multiple blogs on .then() vs. async/await, I thought it would be interesting to just show how my example from the previous blog could be re-written using async/await syntax rather than .then().</p><p>From the previous blog, we had a fetch call and callback functions that looked like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/acd70482d0accb13210c852deb4f1056/href">https://medium.com/media/acd70482d0accb13210c852deb4f1056/href</a></iframe><p>To replace our invocations of .then() on lines 3 and 4, we need to make our callback functions, getResponse() and processJSON(), asynchronous functions using the <em>async</em> modifier.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ca72a12132c5bdaebae0a3bfe40fa35b/href">https://medium.com/media/ca72a12132c5bdaebae0a3bfe40fa35b/href</a></iframe><p>Now, we will use the <em>await</em> keyword anytime we want to obtain the return value of an async function. Await works similarly to .then(). It tells JavaScript to pause our code and wait for the async function to resolve before continuing. In this way, we can impose procedure on asynchronous blocks of code so that they run as they were just procedural code.</p><p>Our new code would then look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd275150078e32f6ab6a659a8a58b968/href">https://medium.com/media/bd275150078e32f6ab6a659a8a58b968/href</a></iframe><p>This block of code will execute in the top to bottom order it is written without the need to chain calls to .then()</p><p>One important thing to know is that attaching the async modifier to a function changes its return type to a <em>Promise</em>. You must then use await anytime you want to capture the <em>value</em> of the resolved promise, which is what you will be after in most cases.</p><p>Check out <a href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Async_await">this explainer</a> from Mozilla for a more detailed explanation of async/await with additional resources, including how to avoid asynchronous slow-down and optimization. For a discussion of async/await vs. .then() <a href="https://www.smashingmagazine.com/2020/11/comparison-async-await-versus-then-catch/">check out this blog</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8bfc74baec08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Writing Ugly JavaScript Fetch Functions]]></title>
            <link>https://javascript.plainenglish.io/how-to-make-your-js-fetch-not-look-so-ugly-f45c89f8bc3a?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/f45c89f8bc3a</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Tue, 11 May 2021 16:10:16 GMT</pubDate>
            <atom:updated>2021-05-16T08:15:23.902Z</atom:updated>
            <content:encoded><![CDATA[<p>This is what a typical JavaScript fetch() function call looks like:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f5a9999d8f1886a5601d6c5f3bccb46/href">https://medium.com/media/4f5a9999d8f1886a5601d6c5f3bccb46/href</a></iframe><p>Let’s break down what makes this so ugly, before we dramatically improve it.</p><p>Perhaps most egregious, is the first .then() statement. We have an anonymous inner function that only performs one action, taking the response from the initial fetch() call and turning into a JSON object that is more easy to work with.</p><p>You can immediately see all the problems with this in terms of readability. First, it’s not DRY. You will pretty much always need to perform this action anytime you get data from the server, so why have we written the code in the middle of this fetch() block rather than in a reusable method?</p><p>While anonymous inner functions are common in JavaScript and other languages, they really should be used sparingly. Nothing about the words “anonymous” or “inner” suggests readability. Anonymous? Why don’t you want to tell me what function this is? Inner? Why are you trying to hide the functionality? Plus, we’ve got the guts of the action just hanging out in the middle of our code.</p><p>The following .then() is usually the thing you actually want to do with the data you get back from the database. That is, it’s the <em>action </em>you want to perform on the data. Wait, aren’t functions actions that we want to perform on data? Yes.</p><p>OK, that’s enough ragging on how fetch() calls are usually written, let’s start writing them the better way.</p><p>The first improvement we can make is take the boilerplate action of the first then() and put it in a reusable function:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/91d7030d086ec0b7f95a696c6aea8829/href">https://medium.com/media/91d7030d086ec0b7f95a696c6aea8829/href</a></iframe><p>The main thing to know for this function is that a fetch() call will always return a response from the server of some sort. You can pass this response as a parameter to your function (that’s the “response” variable in our code here).</p><p>From there, we simply call the .json() function on the response and return the result of that function call, giving us the server response in a JSON format that we can use as we need.</p><p><strong>Note:</strong> We do not include () within the .then() because we are not <em>invoking</em> getResponse(), we are merely <em>telling </em>JavaScript which function to go to when it’s ready.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/16268c1a2d93c2ba61738924969a9bbd/href">https://medium.com/media/16268c1a2d93c2ba61738924969a9bbd/href</a></iframe><p>Now that we have our data, we can process it as we need in another function.</p><p>That function should clearly indicate what the function is doing by its name. For example purposes, we’ll call it processJSON().</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f2d18252accf3160d2f0545776dd8157/href">https://medium.com/media/f2d18252accf3160d2f0545776dd8157/href</a></iframe><p>When we call this function in a .then() after getResponse() we’ll be passed the JSON object returned by that function. So I have named the parameter variable for processJSON() “json” as a reminder of what data we have. You can of course name all of the parameters whatever you want, and may want to name it something more relevant to your application or the data you are working with.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/86568b49eed6f8e7b31e8db7779c4bdf/href">https://medium.com/media/86568b49eed6f8e7b31e8db7779c4bdf/href</a></iframe><p>Wow, our fetch() is now looking much better! Not only do we not have function guts splayed out in the middle of our code, but it’s a lot more DRY since we can just call getResponse() and processJSON() in a fetch() block whenever we need to. We also had a big improvement to readability. What we have now is practically pseudo-code; it reads pretty much exactly as what is actually happening. “Make a fetch, then get the response, then process the JSON.”</p><p>Someone can know exactly how our program works without needing to see the implementation details at all. That is true readability.</p><p>While our fetch() statement definitely looks better, we still have that hard-coded URL passed. It not only looks bad, but might break if we make changes to the back-end, and we’d have to find every instance of it to fix it. I think you know where this is going.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/097bf3a411e93c13d28d3386c53178aa/href">https://medium.com/media/097bf3a411e93c13d28d3386c53178aa/href</a></iframe><p>We’ve saved our fetch path in a constant named following RESTful conventions. We’ve made it easier to keep our code updated and made our fetch even cleaner:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/acd70482d0accb13210c852deb4f1056/href">https://medium.com/media/acd70482d0accb13210c852deb4f1056/href</a></iframe><p>Talk about going from Zero to Hero! Our initial code was messy, non-DRY, and not very readable. We’ve improved greatly on all three accounts. That, is how you write a fetch().</p><h4>But what about POSTing and PATCHing?</h4><p>You’re right, writing to the database with a fetch() call can get pretty messy, mainly due to the need to pass an http object with the fetch() request (lines 3–8 in the snippet below).</p><p>Let clean this up in one fell sweep.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dbd85be10365f198246f7f56d6b14269/href">https://medium.com/media/dbd85be10365f198246f7f56d6b14269/href</a></iframe><p>We’ll write a reusable function called writeServer() that will generate and return the http request for the fetch call.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/77a12d84bf1827d6dbb07d20319eeab4/href">https://medium.com/media/77a12d84bf1827d6dbb07d20319eeab4/href</a></iframe><p>The two parameters to writeServer(), action and data, allow us to use the same function for POST, PATCH, and DELETE requests. We simply specify the http verb when we call the function (action), and include the data we are POSTING or PATCHING.</p><p>If there is none, e.g. a DELETE request, “data” is set to an empty object by default. As an important reminder, you’ll need to include the parenthesis () in the fetch call (line 2 below).</p><p>We are <em>invoking</em> the writeServer() function to get its return value and pass it as a parameter to our fetch() call. It’s a bit easier to remember that if you are passing variables to writeServer().</p><p>A fetch call to create a new Movie in the database might look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f6ebec51abd2f69dc580b1abe34dcbf/href">https://medium.com/media/4f6ebec51abd2f69dc580b1abe34dcbf/href</a></iframe><p>It’s DRY, readable, and flexible. A huge improvement over where we started.</p><p><em>More content at </em><a href="http://plainenglish.io/"><strong><em>plainenglish.io</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f45c89f8bc3a" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/how-to-make-your-js-fetch-not-look-so-ugly-f45c89f8bc3a">Stop Writing Ugly JavaScript Fetch Functions</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The No-Code Revolution is Imminent]]></title>
            <link>https://product-obsessed.medium.com/the-no-code-revolution-is-imminent-8c4915837474?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c4915837474</guid>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Thu, 22 Apr 2021 19:29:55 GMT</pubDate>
            <atom:updated>2021-04-27T15:35:46.956Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*r3XYkul8eYYyF9hNebleAA.gif" /></figure><p>Not too long ago <a href="https://medium.com/geekculture/how-to-launch-an-app-in-2020-96b766d5101a">I wrote</a> about how design prototyping tools like Proto.io, Figma, and InVision were changing the way to build apps and launch products.</p><p>I predicted (guessed) that it wouldn’t be long before these drag-and-drop interface design tools would also automatically write front-end code, changing the way do front-end coding. After all, tools like Zeplin.io and Figma already had the ability to generate HTML, CSS, and XML code from imported designs.</p><p>Not only is that front-end prediction coming closer and closer to reality, back-end programming is being encapsulated in increasingly powerful “No-Code” platforms like Bubble.io, Boundless, and a host of others. The number and power of no-code tools is increasing exponentially and it’s dizzying to see how fast this revolution is happening.</p><p>This blog is a quick update on some of the tools out there for making a web app or mobile app without coding. If you want know how to use no-code prototyping to increase your app’s chance of success, definitely check out my previous article, as it has more strategic tips about using the platforms.</p><h3>The Front-End is Being Abstracted</h3><p>In some ways, we always knew this coming. Front-End code in many cases deals heavily with how assets are laid out on the screen. While there is some logic to how assets and views move and update, a lot of the code is just about where something sits on the screen. It just always seemed that if a PowerPoint slide can figure out where things sit on the slide, we should be able to just move different design assets on a canvas and have the computer figure out the code for their position.</p><p>MondayHero generates the code from your design files and has a code editor. Once you have uploaded the design, you can use the code editor to make changes or additions where needed.</p><figure><img alt="a screenshot of monday hero" src="https://cdn-images-1.medium.com/max/1024/1*Sd4I8RkLHHKfjajcmdk69w.jpeg" /><figcaption>Upload design files to MondayHero and then edit the generated code as needed.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BpzGngXFJHJXrln3U2-IdQ.png" /><figcaption>Zeplin.io also create code snippets from design files</figcaption></figure><p>Boundless and Bubble.io both remove the code aspect completely. You arrange the elements of a page as you like, then the app just runs in a browser without you needing to store the codebase.</p><figure><img alt="boundless example" src="https://cdn-images-1.medium.com/max/960/1*jT0b-9PPLcEjaM3Dinb22Q.gif" /><figcaption>Boundless features a drag-and-drop UI creator.</figcaption></figure><p>Framer, Proto.io, Figma, UXPin (and probably many others) have fewer coding capabilities (although still do generate code), but offer much more in terms of interactivity. You can essentially set up almost every action and interaction that you want your app to have with simple no-code programming and see your ideas come to life immediately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*r3XYkul8eYYyF9hNebleAA.gif" /><figcaption>Proto.io features powerful tools for design prototyping</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*KFh-QIBkGOWMPtUi48Z-8A.gif" /></figure><p>While this isn’t like having a coded application, it can actually help greatly with any software engineers you are working with understand how the app should flow (including yourself!).</p><h3>The Back-End is not Safe Either</h3><p>In the same way that there is a simplicity to Front-End code, CRUD applications also often deal with fairly simple patterns. And new tools are being built that recognize that.</p><p>Bubble and Boundless have simple table creation tools to create and store data types in your application. No migrations, no macros.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*my6UlscQ1JcE0aqBg6GFNg.gif" /><figcaption>Create tables for data types using a GUI with Boundless.</figcaption></figure><p>No-code platforms like these use “workflows”, or series of instructions, to create interactivity that can be defined easily in a graphical user interface. For example, instead of writing out an event listener, you just define the steps you want to happen as a workflow add that workflow to whichever elements you need.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YkSAwHmVLfWh69tNmSmHvQ.jpeg" /><figcaption>Specify programmatic steps in a GUI</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MeE1xk5U5muAoHvQBfc1EA.jpeg" /><figcaption>An example of a HTTP request creation as part of a workflow</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g-7XAijxTrB7LQzHhU5MwA.jpeg" /><figcaption>Then add the workflow to an element.</figcaption></figure><h3>Conclusion</h3><p>Some of these tools are powerful enough to make you feel weird about joining a software engineering program. But I don’t believe that programming jobs are going anywhere anytime soon. I do think these tools will change the way we create applications, but the software engineering field has always been evolving and the way engineers work today is different from engineers in the 80s or 90s.</p><p>My goal in sharing these tools is to help people hopefully create really impressive applications a bit easier and wow prospective clients or employers. As I wrote in my earlier post, compelling design is really important for creating apps that people will want to use, and new software engineers often lack design resources. These tools can make improving design and UI a lot easier and give you the chance to make something really impressive.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c4915837474" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Diving into the World of MIDI APIs]]></title>
            <link>https://product-obsessed.medium.com/diving-into-the-world-of-midi-apis-b18edd0a3367?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/b18edd0a3367</guid>
            <category><![CDATA[software]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[music]]></category>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Thu, 01 Apr 2021 01:19:09 GMT</pubDate>
            <atom:updated>2021-04-05T20:59:00.759Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Future of Hardware Interfaces with MIDI APIs</h3><p>One area of software that I think has been neglected but is now showing promising innovation is hardware interfaces.</p><p>The hegemony of the keyboard and mouse or the touch screen just seems like a broken promise compared to the hands-on, varied control surfaces we were promised in Science Fiction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*uHxA3fBpDdndTF3qnyrvPw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*mqokbHU6iMK68FUWmLUQ9Q.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MRreOXpCqkBrZ2yfHdy8pQ.jpeg" /><figcaption>I remember the future.</figcaption></figure><p>More concerning, the ubiquity of the keyboard and mouse as software controls also means that people are using them more often and for longer to get work done, leading to increased risk of repetitive motion injury.</p><blockquote><em>Want to read this story later? </em><a href="https://usejournal.com/?utm_source=medium.com&amp;utm_medium=noteworthy_blog&amp;utm_campaign=tech&amp;utm_content=guest_post_read_later_text"><em>Save it in Journal.</em></a></blockquote><p>However, there is a budding renaissance in software control surfaces. Styluses or “Pencils” are fairly common, but products like the Surface Dial from Microsoft, or Loupdeck’s editing consoles are really exciting.</p><p>These devices are sometimes purpose built for a specific software program, and sometimes designed to be adapted and used with different programs.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2Fl2JhqcvxdsfQAEbvi%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Fmashable-l2JhqcvxdsfQAEbvi&amp;image=https%3A%2F%2Fmedia1.giphy.com%2Fmedia%2Fl2JhqcvxdsfQAEbvi%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="235" frameborder="0" scrolling="no"><a href="https://medium.com/media/bfac5a4ba775ab76f3bcfd15d41d6e91/href">https://medium.com/media/bfac5a4ba775ab76f3bcfd15d41d6e91/href</a></iframe><figure><img alt="A hardware controller for video editing software from Loupdeck" src="https://cdn-images-1.medium.com/max/1024/1*d5xaql1dJ_2Y5Zma54x_7w.jpeg" /><figcaption>A hardware controller for video editing software from Loupdeck</figcaption></figure><p>The industry that has perhaps seen the most innovation in control surfaces is music production. The capabilities and efficiency of software instruments, like software synthesizers and sampled instruments, has driven demand for hardware surfaces that allow musicians to play and manipulate software instruments. Over time, these control surfaces have extended their capabilities to control recording software such as Digital Audio Workstations (DAWs) with impressive levels of integration.</p><p>At the heart of this innovation, is the <a href="https://www.midi.org/">MIDI standard</a>, a specification for, well, Musical Instrument Digital Interface-ing. MIDI has been continually developed and <a href="https://en.wikipedia.org/wiki/MIDI">improved for 40 years</a>, but it’s strength is it’s simplicity. It is one of the simplest specifications for allowing one device to send signals to another.</p><p>An active community of folks hacking and extending the capabilities of MIDI controller devices has grown as more devices have been released. MIDI APIs are now available to allow more people to tinker and explore with getting different kinds of control surfaces to control different software.</p><p>This blog is a quick review of my first peek into the world of MIDI APIs and programming. I want to make a few notes about what I find, and lay out some plans for potential projects.</p><h3><strong>The Web MIDI API</strong></h3><p>My research naturally began with a search for “MIDI API” to find an easily usable interface to program MIDI. I was immediately introduced to the <a href="https://www.w3.org/TR/webmidi/">Web MIDI API</a>, a new and ambitious initiative by the World Wide Web Consortium (W3C) to allow web browsers to send and receive MIDI signals with MIDI devices.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FY0nknTPz3kWL9VWsJq%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2FLANDR-beats-musicproducer-landr-Y0nknTPz3kWL9VWsJq&amp;image=https%3A%2F%2Fmedia4.giphy.com%2Fmedia%2FY0nknTPz3kWL9VWsJq%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="435" frameborder="0" scrolling="no"><a href="https://medium.com/media/7b4060e11af69bbfe3e124372962da1c/href">https://medium.com/media/7b4060e11af69bbfe3e124372962da1c/href</a></iframe><p>It’s super exciting to see a tool like this being developed, opening the possibility for neat web-based music software programs, but also potentially opening the door to more apps in general supporting MIDI and advancing more options for software control for all kinds of applications.</p><p>As a browser-based technology, the Web MIDI API appears to be oriented around JavaScript. I quickly found tutorials for the API from the <a href="https://developer.mozilla.org/en-US/docs/Web/API/MIDIAccess">Mozilla Developer Network</a> and <a href="https://www.smashingmagazine.com/2018/03/web-midi-api/">Blogs</a>. I will be learning JavaScript soon and so this will definitely be a great side project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*hXT2Lhhj8vqegW6aSIm-Cg.png" /><figcaption>A JS snippet of the Web MIDI API from a tutorial</figcaption></figure><p>Additionally, according to the documentation, the Web MIDI standard is based on OS-specific MIDI implementations like the Windows MIDI API and Apple’s CoreMIDI API. Hopefully the Web MIDI API will be an accessible start that will lead to potentially working with those APIs.</p><h3><strong>Existing MIDI Mapping Apps</strong></h3><p>As I was researching, I also came across applications that are designed to allow MIDI controllers to control various software programs. <a href="https://rsjaffe.github.io/MIDI2LR/">MIDI2LR </a>is an open-source app specifically built to help users connect MIDI controllers to Adobe Light Room. <a href="https://hautetechnique.com/midi/midishortcut/">MIDI Shortcut</a> and <a href="https://midikey2key.de/">MIDIKey2Key</a> are programs that allow you to map MIDI signals from your controller to key presses or macros on your computer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SDfje858WOypraQgvWS5tg.png" /><figcaption>A video of using a music MIDI controller to launch apps in MacOS</figcaption></figure><p>Apps like these represent a quicker avenue to experimenting with new control surfaces for different apps, which is the ultimate goal. Whether to reduce injury from unergonomic devices or to promote creativity and new ideas, continuing to innovate with how people interact with software is an important goal.</p><h3>Conclusion</h3><p>I think the way we control software applications shapes how we think about those applications and what we can do with them. Innovating with new ways of control can potentially expand our understanding how we use software and what we can do with it, and that’s why I think MIDI controllers are so exciting. Stay tuned to this blog as I launch my first MIDI projects and hopefully come up with some cool new ways to interact with software!</p><p>📝 Save this story in <a href="https://usejournal.com/?utm_source=medium.com&amp;utm_medium=noteworthy_blog&amp;utm_campaign=tech&amp;utm_content=guest_post_read_later_text">Journal</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b18edd0a3367" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Launch an App in 2020]]></title>
            <link>https://medium.com/geekculture/how-to-launch-an-app-in-2020-96b766d5101a?source=rss-eaca3aa82ebb------2</link>
            <guid isPermaLink="false">https://medium.com/p/96b766d5101a</guid>
            <category><![CDATA[startup-lessons]]></category>
            <category><![CDATA[venture-capital]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[mobile-apps]]></category>
            <dc:creator><![CDATA[Andre Powers]]></dc:creator>
            <pubDate>Tue, 11 Feb 2020 16:41:46 GMT</pubDate>
            <atom:updated>2021-04-07T21:53:36.469Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to Launch an App in 2021</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BLu7syQ-gNNLMAoc9H0sRg.png" /></figure><p>I’ve recently had the great privilege and pleasure to share some of my experience about launching apps with a number of aspiring entrepreneurs. Having taken two fintech apps from the idea stage to the hands of thousands of users, I learned a lot about what to do and what not to do to launch an app efficiently.</p><p>Based on requests, I’m happy to share my tips here to reach more people, and hopefully reach them before they take the wrong approach to launching their app.</p><p>As an Abstract: The key to launching an app efficiently in 2021 is the “Prototype First” strategy. Prototyping tools like <a href="http://invisionapp.com/">Invision</a>, <a href="http://www.proto.io/">Proto.io</a>, <a href="http://www.zeplin.io/">Zeplin.io</a>, and <a href="http://figma.com/">Figma </a>have changed the game of how to build and launch mobile and web apps. You can build a beautiful, functional prototype that demonstrates the key features of your app <em>without writing a single line of code</em>, and doing this is <em>absolutely key</em> to a successful launch of not just your app, but of your start-up, as you will see. Here’s the playbook:</p><p><strong>Step 1: Start with Design.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L_oyRnK3km8eM9GTbpe5og.png" /></figure><p>Your first task is to find a graphic designer who can design a beautiful, compelling interface and screens for your app. Many first-time founders make the mistake of seeking a software developer first, thinking that the developer will be able to design the interface for the app.</p><p>But coders aren’t graphic designers. There is a huge difference in the ability of most software development shops to make beautiful interfaces and the ability of a graphic designer. Most software engineers will provide you with a standard looking interface, probably just following the basic UX guidelines of whichever platform they are developing for.</p><p>But that’s not good enough. Design is critical to your app’s success. There are more apps out there than anyone needs and most consumers feel they have too many apps on their devices already. If you want to earn a spot on their phone or PC your app must be attractive and compelling. Your app should excite users, and making it look at least as good as the top apps out there will also help earn the confidence of consumers.</p><p>Graphic designers can also help you develop your branding, from a logo and color palette to fonts and typography. A branding palette is really a great asset to have. It makes your company and app look professional and trustworthy, and really comes in handy making sure that your app and company are always presented in the best possible light and never look amateurish.</p><p>My go-to place to find designers is <a href="http://www.dribbble.com/">Dribbble</a> (with 3 b’s). Designers post their work on Dribbble to gain visibility and find jobs. Just search for a term that is related to your app and look through all the beautiful related works that come up. Select works that catch your eye and reach out to the designer to get a quote on your project. You will probably find many talented graphic designers based overseas that have very good hourly rates.</p><p>The takeaways here are that designers are way cheaper than developers, <em>and </em>they will deliver a much better looking interface for your app. Both of these things are critical to a successful launch and that is why you start with design.</p><p><strong>Step 2: Build a Prototype</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NFvPYRu1rBHHNBmeogkITg.png" /></figure><p>After working with your designer to develop all of your interfaces and design assets, you can import the design files of your screens into Invision or Proto.io and turn them into an interactive prototype of your app that demonstrates its functionality without any coding. See for yourself, it’s almost magical the way these tools work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2rmNLVoM2STmw3KM" /></figure><p>Many designers will include prototyping as part of their services. But I recommend you undertake the prototyping on your own if possible. This will save you some billable hours to the designer, but also I personally find prototyping to be really enjoyable. Tools like Proto.io are easy to use, and I think there is something about getting to create your vision of how you want the app to work that is just really exciting as a founder.</p><p>I won’t go into a full tutorial of Proto.io or Invision here, and there is somewhat of a learning curve. But these apps have made creating an interactive demo of your app almost as easy as creating a PowerPoint presentation. You will pick up the basics quickly if you have used anything like PowerPoint before.</p><p>The prototypes you can create seem like real apps, and can even be loaded on a mobile device to demonstrate them as they would be to a user of your app. It’s hard to overstate how game-changing this is for anyone launching an app. I personally believe it’s only a matter of time before someone figures out how to make it so that code is automatically written from the basic interface of a program like Proto.io and that is how we will build apps in the future (at least the front-end).</p><p><strong>Step 3: The Huge Strategic Value of Your Prototype</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5ViFGt1kqrVBHGf3Xr0BXA.png" /></figure><p>A prototype that can show your app’s functionality with a high level of visual fidelity is incredibly valuable. You can use it to pitch customers and test the market for your app without spending very much money at all. This is not just a smart way to do market research before you invest the money to build your app, you could potentially have customers ready to pay for an app that you haven’t even built yet (don’t worry, this is a GREAT problem to have).</p><p>Similarly, prototypes make a much bigger impression when pitching investors. The more concrete your idea is, the stronger the impression it will make on investors. When you can put your “app” in the hands of an investor and they can see how it will look and what it does, it has a much bigger impact on them and makes you seem like you are further along than an idea on a napkin. And when you tell them you already have 20 customers interested in your app just from seeing the prototype, and they’ll probably write you the check to get it built!</p><p>I used prototyping to acquire roughly 20 local merchants to use my app, <a href="http://www.stuypend.com/">Stuypend</a>, before building anything. These users validated our idea for our MVP feature set, and helped us raise our friends and family round because we could show that people wanted to use our app. We just needed to build it for them!</p><p>It’s hard to overstate just how important that ability to obtain potential customers and investors will be at increasing your chances of success with launching the app. It lowers risk <em>and </em>helps secure funding (whether from customers or investors), and simply put, customers (or users) and investors are what you need to be successful. But having a prototype will also provide value when you finally move forward with developing a real app.</p><p><strong>Step 4: Finally Building Your App</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t1OhkigYil3psLNMtyxbkw.png" /></figure><p>Prototypes are great for demonstrating interactions, functionality, and user flows to software developers too.</p><p>A prototype will allow you to show engineers exactly how you want your app to work and <em>greatly </em>reduce back-and-forth about UX details. When you consider that developer hours are the most expensive in the app building process, you can see why it’s such a good idea to move all the hashing of UX/UI details to the design phase instead of during coding. That way developers can easily plow through the work without having to ask questions about UX details, and you won’t have to correct interactions in the app that don’t work how you’d like them to.</p><p>In addition, tools like Zeplin.io and Figma automatically generate HTML, JavaScript, and XML code for implementing designs into the app’s front-end so devs can just copy and paste, saving more time and making sure your app looks exactly how you want (prototyping tools like Invision will often have a feature like this built in).</p><p>When building <a href="https://apps.apple.com/us/app/stuypend/id1275561009">Stuypend</a>, I used these tools to help lower quotes from developers when I was ready to start development. I would start with a spec of my project and get a quote from a developer. Then I would show them that I had the entire app prototyped and that a good chunk of the front-end coding is already done for them, and see if they could lower their quote. Not only did this lower their quotes, they loved the clean and organized “design hand-off” these tools provide to make their jobs easier.</p><p>So that’s my detailed playbook for launching an app the smart way today. Prototyping is not just a useful tool in the design process, it’s a powerful strategy that helps ensure the success of your app by dramatically reducing costs and <em>risk</em>. Coding an app is the most expensive part of launching it. Prototyping allows you to acquire resources (whether investors, customers, or both!) before you take the plunge of expensive development, and will probably help reduce the cost of that development. It’s how to launch an app in 2021.</p><p>Andre</p><p>Founder</p><p>Stuypend</p><p>P.S. Please comment on additional tools as even I am not aware of everything that’s out there. I am always open to your comments on anywhere this playbook can be improved!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96b766d5101a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/geekculture/how-to-launch-an-app-in-2020-96b766d5101a">How to Launch an App in 2020</a> was originally published in <a href="https://medium.com/geekculture">Geek Culture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>