The journey of #100DaysOfCode (@Darine_Tleiss)

Hello @henna.s :wave: ,
Thank you for your kind words & continuous support :star_struck: .
From the first day, you where the one who inspired me, and pushed me to start this amazing journey :smiling_face:.

And of course it will be a pleasure for me to organize some events with you to get the best for our community. :muscle: :dizzy:

Waiting your recommendations and ideas. :eyes:

Have a shining day :heart::smiling_face_with_three_hearts::star_struck:


100daysofcode - Day37

Hello friends :smiling_face:, what’s going on ? :face_with_hand_over_mouth: , I hope you are enjoying your journey as much as I am doing. :star_struck:

In yesterday’s post we talked about personas, why they are used and why do we create them. :eyes:

Today we will dive in a new and interesting topic: the empathy map, a tool used by the designers to identify users need. :boom:

What is an Empathy map ? :thinking:

Empathy maps are easily understood charts that explain what UX designers have learned about a particular type of user. Empathy maps can help break down each interview into digestible pieces of information.

Creating an empathy map :star_struck:

here’s what an empathy map includes:

You can fill out this empathy map with a handful of steps. :face_with_peeking_eye:

  1. Add the user’s name. :label:
    Include the name of the person interviewed in your empathy map. Having a name attached to it will help if you ever need to look back at the original transcript or research, and it’ll distinguish this map from other maps you create.

  2. The “SAYS” square. :loud_sound:
    Use verbatim quotes from the interview. In other words, write down exactly what the person said; don’t summarize it in your own words. If you summarize a quote, you might accidentally interpret the user’s meaning incorrectly. It’s also helpful to try to capture themes in the interview that relate to the product you’re researching.

  3. The “THINKS” square. :thought_balloon:
    Summarize the thoughts expressed by the user. Add feelings the user conveyed through body language, tone, or other noticeable indicators, even if they didn’t verbally express them to you. You can make inferences for some of these feelings, but you have to be careful not to make assumptions about the user. You can always ask your user for clarification on their body language if you find any contradictions.

  4. The “DOES” square. :muscle:
    Detail on steps and actions a user takes to overcome challenges they faces.

  5. The “FEELS” square. :smile: :dizzy_face: :rage:
    List the feelings the user expresses. The notes you include may overlap with some of what you listed in the “THINKS” square. That’s okay! :+1:This process is meant to be a thorough documentation of your observations. If you’re the person performing the interview, you might notice signs of feelings like anger :rage:, frustration :triumph:, excitement :grin:, and others. If the user doesn’t explicitly mention any feelings during the interview, you can probe for feelings with the question: “How does this make you feel?”

Types of empathy maps :face_with_monocle:

It’s important to understand that there are two types of empathy maps: one-user empathy maps and aggregated empathy maps (also known as “multiple-user empathy maps”).

  1. One-user empathy maps :point_up_2:
    One-user empathy maps are created by taking the data from one user’s interview and turning it into an empathy map, like the example earlier in this reading. This approach helps designers distill a single user’s thoughts, feelings, and traits into a format that’s easier to gather data from.

  2. Aggregated empathy maps :busts_in_silhouette:
    An aggregated empathy map, represents a group of users who share similar thoughts, opinions, or qualities. Aggregated empathy maps are created by creating multiple one-user empathy maps, then combining the maps where users expressed similar things into a new empathy map. This helps designers identify segments, or groups of people with similar tendencies, who will use the product.


100daysofcode - Day38

Hello friends :smiling_face:, how it’s going on. A new day is here, the 38/100 of this amazing journey. As everyday a dose of new information is required to wrap the day. :star_struck:

In yesterday’s post we talked about the empathy map, it role and how we implement it. :face_in_clouds:

In today’s post, we will talk about user stories a helpful way to understand your users in a deep way. :comet:

What is a User story ? :face_with_monocle:

User story is a fictional one-sentence story told from the persona’s point of view to inspire and inform design decisions. This is a great opportunity to use your imagination as you create the stories that capture the needs of your users.

User stories should be written in the following format : :point_down: :point_down:

Using this :point_up_2: format is a clear way to ensure your user story is communicating everything you need to know about the persona.

User stories can also serve as a “checklist” to make sure you’re addressing and solving the key problems your users might face when engaging with your product.

Best practice for user stories : :muscle: :fire:

  • keep them short
  • impactful
  • to the point
  • with a clear action and benefit.

Different users have different needs, so be sure to practice empathy and keep their unique needs in mind when writing user stories.

To help you write the most effective user stories, check out this article from Interaction Design Foundation about how to write user stories.

Representing your users :face_with_peeking_eye:

Personas and user stories represent the needs of the users you’re designing for. The more detailed and accurate your personas and user stories are, the better you will be at designing products that meet their needs.

Remember, as a UX designer, the user always comes first :point_up: in all of your work, so it’s important to understand their points of view.


100daysofcode - Day39

Hi guys :saluting_face:. Day 39 is already here :partying_face:. As everyday a dose of new information is required to wrap the day. :star_struck:

In yesterday’s post we talked about the user stories and it is best practices. :face_in_clouds:

In today’s post, we will talk about accessibility and few considerations for you to take into account when conducting research. :woman_with_probing_cane: :woman_in_manual_wheelchair:

what is Accessibility ? :face_with_monocle:

Accessibility is the design of products, devices, services, or environments for people with disabilities. :man_with_probing_cane: :woman_in_motorized_wheelchair:

Designing for accessibility is about considering all users’ journeys, keeping their permanent, temporary, or situational disabilities in mind.

Here are a few considerations for you to take into account when conducting research during the empathize phase of the design process.

  1. Touch: :handshake: How would you design for users who have use of one arm, either permanently, temporarily, or situationally?

    • Decide where to place buttons within your design based on several different hand sizes.
    • Create a feature that allows double taps to avoid accidental icon clicks.
    • Enable the one-handed keyboard feature and general keyboard compatibility.
    • Allow button customization for easy access to information that the user finds most important.

  1. See: :eyes: How would you design for users who have limited vision, either permanently, temporarily, or situationally?

    • Use a larger font to create a reader-friendly design of the app.
    • Ensure the app and the images have alternate text that can be read by a screen reader.
    • Detect whether the user is operating a motor vehicle.
    • Design the app with high contrast colors.
    • Don’t rely on text color to explain navigation or next steps. For example, don’t use red text alone as an indicator of a warning. Instead, your design should include explicit instructions.

Customizable text

Customizable text , is a feature that allows users to change how text is displayed in order to read the text more easily. Text customization involves changing everything from the color or font to the size or even the spacing of the text.

  1. Hear: :hear_with_hearing_aid: How would you design for users who have limited hearing, either permanently, temporarily, or situationally?

    • Don’t rely solely on sounds to provide app updates, like a new message notification. Instead, enable haptics, which are vibrations that engage a user’s sense of touch, and notification lights.
    • Apply closed captioning to all videos.
    • Provide a text messaging system within the app to allow users to communicate through writing.

  1. Speak: :speech_balloon: How would you design for users who cannot speak, either permanently, temporarily, or situationally?

    • Provide written intros, descriptions, and instructions for users, in addition to video-based content.
    • Provide Real-Time Texting during phone calls with users or with app support.
    • Arrange alternatives for automated systems that rely on speech recognition.
    • Provide an in-app messaging system that allows the use of emojis and image uploads.

100daysofcode - Day40

Hello friends :smiling_face_with_three_hearts: , today marks our 40th day in this amazing 100 days of code. :star_struck:

In yesterday ’s post we talked about accessibility in UX. :woman_in_manual_wheelchair: :woman_with_probing_cane:

Today we will discuss the problem statements :exploding_head:

The connection between pain points and problem statements :handshake:

Pain points are any UX issue or friction that frustrates the user and blocks them from getting what they need. Minimizing pain points keeps users happy and encourages them to keep interacting with the product.

Four categories pain points can fall into:

  • Financial , or money-related pain points.
  • Product , which are pain points related to quality issues.
  • Process , which are pain points related to the user’s journey.
  • Support , which are pain points related to getting help from customer service.

Identifying the pain points your user is experiencing will help you find potential problems that your design can solve.

Now that you’ve identified user’s pain points, you need to be sure you know enough about his needs to write a problem statement.

What is a Problem statements :thinking:
provide a clear description of the user’s need that should be addressed. To build a problem statement, you can utilize the 5 Ws framework.

The 5 Ws and H: who, what, when, where, why, and how :face_in_clouds:

The most common framework used to create problem statements is the 5 Ws and H framework. After you define the user’s pain points, you can answer who, what, when, where, why, and how to solve the user’s problem.

  1. Who :bust_in_silhouette: is experiencing the problem? Knowing your users and their background is key to creating successful solutions for them.

  2. What :rage: are the pain points you’re trying to solve? Determining a user’s pain points early allows you to answer the rest of these questions and clarify the context of the pain points.

  3. Where :earth_asia: is the user when they’re using the product? A user’s physical context matters to your design.

  4. When :clock12: does the problem occur? Maybe it’s right after the end of a long and tedious process, or maybe it’s something that happens daily. Knowing when the problem occurs can help you better empathize with the user’s feelings.

  5. Why :thought_balloon: is the problem important? Knowing how this problem affects your user’s experience and life will help to clarify the potential consequences.

  6. How :checkered_flag: are users reaching their goals by using the product? Understanding how users reach their goals allows you to map the user journey that they take through your product.

Now that you’ve thought through your user’s needs, you’re ready to define the final problem statement. :muscle:

The problem statement formula

How do you create a problem statement? :face_with_monocle:

Start by defining who the user is and what their needs and motivations are.
Here’s the formula we introduced :

The impact of problem statements :comet:

  • Problem statements provide clarity about your users’ goals and help UX designers identify constraints that prevent users from meeting those goals.
  • Problem statements also help your team measure success.

The designs you create matter! Empathize with your user as much as you can to make a product that they’ll want to interact with and use every day.


100daysofcode - Day41

Hey friends :grin:, the counter :arrows_counterclockwise: is running and a new day is already here. The 41/100 of this amazing journey. :partying_face:

And as everyday let’s learn something new after exploring problems statements in UI UX. :exploding_head:

For today we will dive :goggles: in the hypothesis statement, what is an hypothesis statement how to write them. :smiling_face:

Define hypothesis statements :face_with_monocle:

A hypothesis statement is an educated guess about what you think the solution to a design problem might be :thinking:. You know the challenges users are facing, so it’s time to consider how your designs can alleviate their pain points.

Hypothesis statements don’t have a single standard formula to follow, but there are two common methods you can try using to write one.

  1. First, you can use the if / then format to come up with a hypothesis statement.

Example: :eyes:

  • If user downloads delivery app, then they can utilize the “simplified” mode setting to view only the basic app functions.
  • If user signs up for the delivery app, then they will quickly and easily order food that fits their want.
  1. Second, you can use the we believe format to come up with a hypothesis statement.

Example: :eyes:

  • We believe that a simplified mode of the delivery app for userwill allow them to receive their orders efficiently.
  • We believe that easy access to available food for userwill increase the amount of food they will order.

If / then statements focus directly on the needs of users. On the other hand, we believe statements take the perspective of your team into account, while remaining empathetic to the needs of users.

You might encounter situations where you have multiple hypothesis statements for one problem statement. That’s okay! There will always be multiple solutions for the problems that users are facing. Your job as a UX designer is to use your creativity and problem-solving skills to decide which solutions work best for the unique users you’re designing for. :star_struck:

Hypothesis statements help you narrow down your research insights into goals for your product, so you can stay focused on the wants and needs of your users. :muscle:


100daysofcode - Day42

Hi guys :wave: , hope your are doing great :smiling_face_with_three_hearts:. we have reached the 42th day in this journey. :exploding_head:

Yesterday we discussed problems statements. :grin:

In today’s post we will talk about value propositions and how to create them. :star_struck:

what is a Value Proposition :thinking:

Value propositions summarize why a consumer should use a product or service.

Value proposition example :face_with_monocle:

Check out a product you might recognize - Gmail – and ask yourself if you can identify a few of its value propositions. When Google debuted Gmail in 2004, they were entering an already crowded market of free email services.
Gmail offered:

  • The ability to send and receive emails for free
  • Email sorting, archiving, and starring functions
  • Spam filtering for inboxes
  • Email conversation views
  • 1 gigabyte of cloud storage

Two of the items on that list were unique offerings that no other email services provided at the time:

  1. Email conversation views, which put individual emails in the context of a larger thread.
  2. An entire gigabyte of storage, which was 1,000 times the amount of storage that competitors offered.

Those were Gmail’s unique value propositions.

Build value propositions :building_construction:

Everything that your product has to offer might seem obvious to you, but you have to put yourself in the mind of your users. Users don’t know your product or understand its value yet. That’s where value propositions come in.

To start, you need to do some research in order to answer these two questions : :point_down: :point_down:

  • What does your product do? Clearly explain the offering that your product provides users.
  • Why should the user care? Describe how your product addresses users’ pain points.

Once you’ve answered these questions, you can follow a series of steps to focus in on your product’s unique value proposition.

  1. Describe your product’s features and benefits. :thought_balloon:
    Create a list of all the great features and benefits of your product, big and small. Don’t hold back; list everything that comes to mind and then narrow it down later.

a wall covered in sticky notes of various features. Easy-to-use app design, complimentary doorbell cameras, no hidden fees, quick matching with qualified users, calendar blocking, monthly subscription, background checks, convenient lockers for your house keys, late-notice cancellation fees, rating system, professional referral only, rate negotiation,.

  1. Explain the value of the product. :face_in_clouds:
    Anything that you identify as a value proposition needs to be beneficial to your users.

  1. Connect these features and benefits with the needs of your users. :dizzy:
    The goal is to identify what’s truly valuable to the user and not just a cool feature that users didn’t ask for. To determine value, take the personas you’ve developed and pair each persona with a value proposition that meets their biggest pain point.

  1. Review your official value proposition list. :page_facing_up:
    You’ve narrowed your list down of lots of benefits and features by matching them with actual user needs. Now it’s time to review the list of value propositions your product offers.

One of the most important things to know about value propositions is that they need to be short, clear, and to the point.
Users want to be able to easily identify exactly how your product will meet their unique needs and what sets your product apart in the market.

Sometimes users won’t know what they need until you explain it to them. That’s the real heart of product design innovation. :100:


100daysofcode - Day43

Hello friends :smiley:, our daily counter, increased by 1 :sunglasses:. And it’s already the 43th / 100 :open_mouth:, So a dose of new knowledge is required to wrap the day successfully. :dizzy:

In yesterday post, we talked about value proposition where we learned how to build them. :star_struck:

You’ve empathized with your users and determined their pain points. So today we will start thinking of ways to solve your user’s problems. Ideating is an exciting step in the journey as a UX designer! :exploding_head:

What is Design Ideation :thinking:

Design ideation is the process of generating a broad set of ideas on a given topic without judging or evaluating them. When you start thinking of ideas, you want to come up with as many as possible. The aim is to generate lots of ideas, even ones that may seem ridiculous at first. Sometimes your most outrageous idea will turn into a great and unique solution!

Preparing for ideation :page_facing_up:

Before you start design ideation, you’ll need to do a bit of prep work.

  1. Empathize with your user. :busts_in_silhouette:
    Empathizing is the first step in the design process. You need to know who you’re solving for and what their needs are. We emphatize with users by creating empathy maps, personas, user stories, and user journey maps.

  1. Define the problem. :rage:
    Defining is the second step in the design process. The problem you’re trying to solve should be well-defined, so that everyone on your team can think of ideas to solve the same problem. Knowing exactly what problem you need to solve will also keep your users’ needs top-of-mind.

  1. Establish a creative environment. :shamrock:
    You’ll need a comfortable space where everyone on your team can get together and present their ideas. If you’re meeting in person, choose an ideation space that’s different from your usual workspace. If you’re ideating virtually, try to find a different space in your home that’s free of clutter and distractions.

  1. Set a time limit. :timer_clock:
    There are an endless number of possible products and features you could design, so give yourself plenty of time to come up with ideas. However, you can’t brainstorm forever, so you’ll also need to set a time to stop brainstorming and start thinking more deeply about the ideas you’ve come up with.

  1. Assemble a diverse team. :two_men_holding_hands: :couple:
    You’re trying to come up with as many different ideas as possible. An inclusive team of people, with different races, genders, abilities, and backgrounds, will help you come up with all kinds of solutions.

  1. Think outside the box. :thought_balloon:
    Don’t limit yourself to traditional ideas and solutions. If you have a cool idea that seems a little different, write it down! Think big and get creative while ideating.

There’s no right or wrong way to practice design ideation. There are many techniques you can use to come up with ideas.

The importance of design ideation :rocket:

While design ideation can take a significant amount of time, it’s also a lot of fun! You’ll generate many possible solutions, and you’ll end up using one, or a few, of your original ideas. This is perfectly normal in the UX design process, and it’s an exciting part of the working with a team.

Design ideation encourages you to come up with solutions that are unique. Don’t settle for your first solution. In fact, the first few solutions you suggest are often the least creative because they’re the most obvious. When generating ideas, you should use your creative powers to their full potential. :boom:

The more effort you put into empathizing with your users, defining the problems they’re facing, and coming up with ideas for solutions, the better your end result will be. :rainbow:


100daysofcode - Day44

Hello folks :smiling_face:, the 44th of 100 is reaching it’s end :sunrise_over_mountains: . A dose of new information is coming to wrap the day in a fun way. :star_struck:

In yesterday post we talked about design ideation, and how such process work. :smirk:

In today post we will talk about competitive audit, its benefit in developing a good UI. :sunglasses:

What is Competitive audits ? :thinking:

A competitive audit is an overview of your competitors’ strengths :muscle: and weaknesses :weary:. Analyzing the brands and products of competitors, or the companies who offer similar products as you do, can give you a well-rounded foundation of knowledge about the market your product will enter. That knowledge will carry into your designs and help you create a product that’s helpful and unique for users. :rocket:

Your competition falls into two categories: :dizzy:

  1. Direct
  2. Indirect

Who are Direct Competitors ? :face_with_peeking_eye:

Direct competitors are companies that have offerings similar to your product and focus on the same audience.

Who are Indirect Competitors ? :face_in_clouds:

Indirect competitors can have a similar set of offerings and a different audience, or a different set of offerings with the same audience. Examining both of these competitors can offer insights about the path your designs might take and the users that you’re designing for.

Why are competitive audits important? :point_up:

Consider how much work your direct and indirect competitors have already done to design and market their products to users. They’ve already had an impact on the industry that your product will enter. Studying these companies, their designs, and their user feedback is a fantastic source of information. :newspaper:

Competitive audits can offer many benefits throughout your ideation phase, including: :eyes:

  • Giving you an idea of products already in the market and their designs.
  • Suggesting ideas to solve early problems that you’re facing with your own designs.
  • Revealing the ways that current products in the market are not meeting users’ needs.
  • Demonstrating the expected life cycle of a product in the same market as yours.
  • Informing all the different iterations your product could take and how those performed for your competitors.

With these benefits in mind, you can work with your team to identify the features and qualifications that you think are vital to your product :fist:.
You’ll focus your audit on the parts of your own design that you want to learn the most about, like the user flow through your app or the navigation within the app.

By investing time into competitive audits, your team will be able to learn from the mistakes of your competitors and can avoid making those mistakes yourselves. Think of audits as a tool to help you create something for your users that’s completely different from the competition, combining all of the strengths of your competitors’ offerings into one fantastic product! :comet:


100daysofcode - Day45

Hi guys :wave:, the 45th of 100 is already here :star_struck: . Let’s wrap this day with new information. :dizzy:

In yesterday’s post we will talked about competitive audit , its benefit in developing a good UI. :sunglasses:

In today post we will talk about How Might We , and it is best practices. :eyes:

what is How Might We ? :thinking:

The “How might we” exercise is one of the most common ways to approach the ideation process.
it is a design thinking activity used to translate problems into opportunities for design. During a HMW, you’d create a list of questions that start with “How might we” and use those to spark ideas for solutions.

Frame HMW questions :comet:

  1. Think of how you might use any positives in the problem as a solution.

  1. Think of how you’d solve the opposite of the problem you’ve outlined.

  1. Think of ways to completely change the process.

  1. This is especially helpful for long, complex problems.

  1. Think of how to remove the negative part of the problem entirely.

  1. Take any negative adjectives and try to turn them into positives.

  1. Remove or change any processes that you assume have to be in place.

Best practices for thinking of HMWs :muscle:

  • Be broad :white_check_mark:
    A good HMW should allow for multiple solutions. For example, one of the earlier questions, How might we make keeping track of tickets fun and competitive?, can be answered in countless ways.

  • But don’t be too broad :no_good_woman:
    You want your HMWs to be comprehensive, but narrow enough to keep your solutions focused. An example of a HMW question that is too broad is: How might we make ticketing better? This HMW doesn’t provide clear enough guidance to come up with ideas for solutions.

  • Make multiple drafts :newspaper:
    It’s okay to change your HMW questions after you’ve written them. If you find that your HMW doesn’t help you think of any useful solutions, change it up!

  • Be creative :exploding_head:
    HMWs are meant to be imaginative and even fun.

  • Write as many HMWs as you can :spiral_calendar:
    The more HMWs you have, the more solutions you can come up with. If you can make more than one question out of the frameworks you’ve learned, then go for it!


100daysofcode - Day46

Day++ :nerd_face:, Hey folks :wave: yes its the 46th day of this non stoppable journey. Our counter increased by one, so now its we have to learn some new information and wrap our day in a funny way. :star_struck:

Yesterday we talked about the How Might we process and it’s best practices. :ok_hand:

Let’s dive more in today post to explore one of the core design sprint methods, Yeah you guessed it: Crazy Eights :8ball:

Crazy Eights :exploding_head:

Another popular design ideation exercise intended to help you think of several ideas in record time.
Crazy Eights is a great way to get ideas flowing for any design problem you need to solve.
With Crazy Eights, you’ll sketch eight different designs, each with a new idea for solving the user’s problem. The best part? It only takes eight minutes!

How it works: :thinking:

  • Start with a large sheet of paper. :page_facing_up:
    Fold the paper in half, then fold it in half again, then in half one more time. When you unfold the paper, you’ll have eight squares to sketch in.

  • Grab something to draw with. :paintbrush:
    A lot of designers prefer to draw using Sharpies, but a pencil or pen will work too. You can use whatever you already have to draw.

  • Set your timer to eight minutes. :hourglass_flowing_sand:
    You’ll have one minute to sketch each design idea.

  • Let the ideas flow. :thought_balloon:
    Draw any and every solution that comes to your mind. If you have more than eight ideas, feel free to repeat the exercise.

Best practices :muscle:

  • Do a creative warm-up exercise. :cityscape:
    Complete an activity where you draw the person next to you without looking at your paper, or have everyone draw their own interpretation of a word or phrase. Starting to put pen to paper like this will get you in the mindset to sketch.

  • Make sure your problem is well defined. :dart:
    Develop a set of Crazy Eights for one How might we question or one problem statement at a time.

  • Don’t judge your ideas. :no_good_woman:
    Ideating is all about creating lots of ideas, not creating perfect ones! Sketch any and every idea you have until your paper is full, no matter how crazy it might seem.

  • Don’t judge other people’s ideas. :rage:
    Keep an open mind when other people are presenting their sketches.

  • Include a diverse group. :man_cook: :teacher: :woman_in_manual_wheelchair:
    Since Crazy Eights are often done in a group setting, it’s best that your group represents a variety of work roles, experiences, abilities, genders, and backgrounds. This will help your team have a wide range of ideas to choose from.

  • Don’t be afraid of sketching. :pencil2:
    You don’t have to be an artist to be a UX designer, and your sketches during Crazy Eights don’t have to be perfect. You just need to clearly communicate your ideas. Stick figures are perfectly fine!

Benefits of Crazy Eights :face_with_monocle:

  • Generates a lot of ideas in a small amount of time . If you have five people do the exercise at the same time, you’ll have 40 potential solutions after only eight minutes. That’s a lot of ideas!

  • Forces you to think outside the box because you have to come up with many ideas in a short timeframe, without judging them. This means that you will have lots of unique, nontraditional solutions to consider.


100daysofcode - Day47

Hello folks :wave:, a new day :sunrise_over_mountains:, my daily dose of knowledge is ready. :star_struck:

In yesterday’s post we talked about the crazy eight :8ball: process and how it work in deep details.

And after wrapping the UX part successfully, today we will move to dive in the UI one, by starting with the user-flow and how to create it. :exploding_head:

Outline a user flow

Designing an efficient product requires a full understanding of users and their needs. There’s a lot that you can do with knowledge about the people you’re designing for.
You can even predict users’ needs before they know what they want or need!

One example of predicting user needs is the process that happens when you order food :green_salad: from a restaurant.
The cashier asks questions :grey_question: about condiments for your burger :hamburger:, whether you want a side of fries :fries:, and if you’d like a water or soda to drink. :cup_with_straw:
The cashier is anticipating your needs as a user and meeting those needs, possibly before you recognized those needs yourself.

As a UX designer, you can anticipate user needs when interacting with your product.
A clear and simple way to outline this process is by creating a user flow.

What is a User Flow ? :thinking:

A user flow is the path taken by a typical user on an app or a website, so they can complete a task from start to finish.

UX designers often outline the user flow before they start to design because it can help to picture how users will move through the app or website.

You need to determine: :point_down:

  • What actions will users take in the app?
  • What decisions will users make?
  • What screens will users experience after taking action or making a decision?

Draw a user flow :memo:

UX designers often outline user flows with common shapes: circles, rectangles, diamonds, and lines with arrows. Each shape represents an interaction the user will have with the product you’re designing.

  • Action: :o: The actions users take when moving through a product design are represented as circles. In other words, circles show steps that must be taken to complete a task from start to finish.

  • Screen: :newspaper: The screens of a digital product that users will experience while completing tasks are represented as rectangles.

  • Decision: :diamond_shape_with_a_dot_inside: Diamonds represent points in the user flow where users must ask a question and make a decision. The decision users make will either move them forward through the flow or back to an earlier part of the flow.

  • User flow direction: :wavy_dash: Lines with arrows tie everything together and display the flow of information. Solid lines indicate forward direction through the user flow, and the dotted lines indicate backward direction or returning to a previous page.

Creating a user flow is a solid step. As a UX designer, one of your best tools :dart: is being able to outline the path that users will take to complete a task in your product.


100daysofcode - Day48

G’ Day guys :star_struck: , 48 days are already wrapped, I hope you are enjoying my content and counting with me toward the happy ending. Everyday we learn something new to share it and make an impact. :dizzy:

In yesterday post we talked about the user flow and how to create it. :smiley:

Today we will move to dive in a new amazing topic. The story boards, there role and how to create them to facilitate your UI process. :exploding_head:

What is a storyboards :clipboard:

A storyboard is a series of panels or frames that visually describes and explores a user’s experience with a product. Telling a story through visuals is often more effective than using words.
Storyboard should focus on just the most important parts of a user’s experience with a product.

The four key elements of a storyboard are: :point_down: :point_down:

  • Character : States the user in the storyboard. :bust_in_silhouette:
  • Scene : Gives designers a way to imagine the user’s environment. :rice_scene:
  • Plot : Describes the solution or benefit offered by the design. :1st_place_medal:
  • Narrative : Describes the problem the user is facing and how the design will solve this problem. :rage:

There are two common types of storyboards in UX design, both of which incorporate these four key elements:

  • Big picture storyboards :white_medium_small_square:
    Focus on what the user needs, their context, and why the product will be useful to the user.
    Big picture storyboards are often used early in the design process when designers are trying to get stakeholders to support their ideas.

  • Close-up storyboards :white_small_square:
    Concentrate on the product and how it works. They’re best used in the middle to the end of the design process.

Create a big picture storyboard :white_medium_small_square:

  1. Start with a problem statement
    This will help establish character and set the scene for your storyboard.

  2. Create a goal statement :checkered_flag:
    Your goal statement helps you determine a plot (the benefit or solution of your design) for your storyboard.

  3. Set up the storyboard :clipboard:

The storyboard template. At the top of the page, there’s a place to describe the scenario. On the template itself there are spaces for images and descriptions of action.

  1. Add the storyboard scenario :rice_scene:
    Begin filling out the storyboard template by adding the scenario

  2. Draw one idea per panel :memo:
    The first panel is used to set the scene for the story. Then with each additional panel, think about actions that push the story forward and how the user feels in each panel

  3. Expose pain points for the user along their journey :rage:

  4. Include the user goal or conclusion in the final panel. :white_check_mark:


Create a close-up storyboard :white_small_square:

To create a close-up storyboard, steps 1-4 are the same as the big picture storyboard process:

  1. Start with a problem statement

  2. Create a goal statement :checkered_flag:

  3. Set up the storyboard :clipboard:

  4. Add the storyboard scenario :rice_scene:

  5. Draw one idea per panel :memo:
    Close-up storyboards focus on the product . For this close-up storyboard, think about which product details you want to draw attention to on each panel and why. You want to demonstrate the user flow within the product and how each action within the product will lead to the next screen.



100daysofcode - Day49

Hi guys :wave:, the 49th of 100 is already here :star_struck: . Let’s wrap this day with new information. :dizzy:

In yesterday’s post we talked about story boards , their role and how to create them to facilitate your UI process. :sunglasses:

In today’s post we will talk about UI process , starting with Sketching, Wireframing, Mockup and finally Prototyping. :thinking:

A design solves a real problem that users are experiencing :dart:. And a strong design always puts the user front and center. :bust_in_silhouette:

A design can have different levels of fidelity. In UX, fidelity means how closely a design matches the look-and-feel of the final product.

  1. Low fidelity: :memo:
    If a design is low fidelity, that means it has a lower amount of complexity and
    is less refined or polished.
    We call low-fidelity designs lo-fi for short.
    UX designers use low-fidelity designs when we want to get ideas out quickly and
    leave room for exploration.

  2. High fidelity: :framed_picture:
    If a design is high fidelity, that means it closely matches the look-and-feel
    of the final product and is more refined or polished overall.
    We call high-fidelity designs hi-fi for short.
    UX designers use high-fidelity designs when we want to test a design that looks like a real product and get more specific feedback from users.

Sketch :memo:

A sketch is a very simple representation of an idea, it is quick and rough -usually handmade - and often done during a brainstorming session with the team .

The Goal of Sketching ? :white_check_mark:

the Sketch’s main goal is to outline the product’s layout before more details are added in future steps of the design process.

Wireframe :black_square_button:

Wireframes establish the basic structure of a page, :stop_sign: before any visual considerations, like color :rainbow: or images :fireworks:, are added.

Why do we need to wireframe? :thinking:

  1. Wireframes serve as an outline to get the team on the same page early in the project.
  2. Wireframes highlight the intended function of the product.
  3. Wireframes help designers save time and resources.

In this step , you plan the layout of elements. You can add simple shapes that represent where you want to implement images :white_circle: , headings :wavy_dash:, text or icons :white_large_square: , along with comment of how the interactions will work.

You can compare wireframes to a building blueprint :film_strip: it will guide builders during the construction :building_construction: ,but is not ready :construction: to be lived in yet.


100daysofcode - Day50

Hey folks :smiling_face_with_three_hearts:, the first amazing half :star_struck: is wrapped successfully. What an amazing journey filled with excitement and knowledge. :dizzy:

In yesterday’s post we dived in the sketching & wireframing process. :face_with_peeking_eye:

Today let’s break the loop to discover the Gestalt principles then we resume the loop to dive in the other mentioned topics. :open_mouth:

Gestalt Principles in wireframes :exploding_head:

The human brain makes sense of the world around it by building logic, patterns, and structure. Gestalt Principles describe how humans group similar elements, recognize patterns, and simplify complex images when we perceive objects.

These principles guide how humans view the designs around them in everyday life. In the wireframes you’re creating, you can apply Gestalt Principles to organize content so it is visually pleasing and easier to understand.

Three of the Gestalt Principles: similarity, proximity, and common region.

  • Similarity :busts_in_silhouette: means that elements that look alike (in shape, size, or color, for instance) are perceived to have the same function.

  • Proximity :sparkles: means that elements that are close together appear to be more related than things that are spaced farther apart.

  • Common region :stars: means that elements located within the same closed area are perceived to be grouped together.


100daysofcode - Day51

Hey friends :smiling_face_with_three_hearts:, today marks the first day in our second amazing half. 51/100 are done and they were full of energy, motivation and consistency to learn new topics :dizzy:.
So let’s to continue this streak and learn some new information. :star_struck:

In yesterday’s post we talked about the Gestalt principle. :face_with_peeking_eye:

In today’s post we will explore how to plan a UX research study. :exploding_head:

What is UX Research ? :face_with_monocle:

UX (user experience) research is the study of learning what end users of a system or product need and want, then employing those insights to enhance the design process for products, services or software.

UX Research Study - Plan

  1. Introduction :

    • Title : A few words about the focus of the study :pen:

    • Author: Your full name, job title or role, and email address on one line :bust_in_silhouette:

    • Stakeholders: List the names of project stakeholders and their roles :busts_in_silhouette:

    • Date: Update the date listed every time you edit this plan :date:

    • Project background: What led you to conduct this research? :thinking:

    • Research goals: What design problems are you trying to solve for the user and/or the business? How will the results of the research affect your design decisions? :checkered_flag:

  2. Research questions :

    • What are the questions your research is trying to answer? :interrobang:
  3. Key Performance Indicators (KPIs) :

    • How can you measure progress toward the research goals? :straight_ruler:

    • KPIs might include: Time on task, use of navigation vs. search, user error rates, drop-off rates, conversion rates, system usability scale (SUS), etc.

  4. Methodology :

    • How will you collect data? How will you analyze the data once you get it? :bar_chart:

    • The methodology should be detailed so that other researchers can understand what you did, the choices you made, and the limitations of the methods employed to decide if or when further research is needed.

  5. Participants :

    • Who will you include in this study? What characteristics do the participants have? Why did you choose them? :woman_artist: :man_construction_worker: :woman_in_manual_wheelchair:
  6. Script :

    • What questions will you ask study participants? :memo:

100daysofcode - Day52

Hello folks :wave:, it’s day++ and some new knowledge is ready to be shared with this amazing community.

Yesterday we talked about the UX research study and how to plan for it. :star_struck:

Today, after a small break :ok_hand:, we will resume the UI process to explore the Mockup and Prototyping phases. :exploding_head:


The mockup is a high-fidelity representation of your idea. It gives a realistic perspective of how things are going to look in the final design. :national_park: :national_park:

In this step you include all the visual details of your digital product:

  • Layout layout

  • Spacing img

  • Text :memo:

  • Icons :first_quarter_moon:

  • Buttons :radio_button:

  • Typographytypography

  • Graphics :bar_chart:


Prototype is a high-fidelity representation of the final product, it is interactive with clickable button :pause_button: and links :link: behaving and acting like the actual app or website.

Using a prototype is almost like using the real product :iphone: :calling:, so once all the stakeholders are happy with it, then you can start the development phase and bring your idea into life. :dizzy:



100daysofcode - Day53

Hello friends :star_struck:, the days loop increasing in a fast way :exploding_head:. Today marks the 53th day from our amazing 100 days of code challenge. :smiling_face_with_three_hearts:

In yesterday post we discovered the mockups and prototyping. :grin:

In today post we will talk about the last phases in the UI process including the testing, and the measurement before and after launching. :dizzy:


Put ideas in front of users, get their feedback, and refine the design.
It is important to understand that the earlier you test, the easier it is to make changes


Launch and measure

Your work as a UX designer does not stop with releasing a product. User experience is an ongoing process that continues for as long as a product will be used by people.

Identifying when a design is complete :white_check_mark:

As you continue to iterate, you might wonder :thinking: how you’ll know when you’ll be finished working on a design project.

There are some important questions to ask yourself to help you decide whether your designs are complete :bangbang:

  • Do the designs represent the intended user experience?
  • Have placeholder text, icons, and imagery been replaced with finalized assets?
  • Are participants or users able to interact with and interpret the designs without external guidance?
  • Do the designs follow the existing design system?
  • Do the designs follow common interaction patterns for their respective platforms?
  • Do users have a clear path when something goes wrong?
  • Is the design accessible?

If you can answer “YES” to all of these questions, then you’re in a good place to consider your designs complete! :trophy:

Your designs should fulfill the scope of the project that was set initially and address the user problem that you set out to solve.


100daysofcode - Day54

Greetings everyone :hugs:, As everyday a dose of new information is required to wrap the day. :star_struck:

Today we will learn about designing across devices. :iphone: :desktop_computer: :computer:

As a UX designer, it’s important to consider how the designs you create will adapt for multiple devices, including desktop computers :desktop_computer: , tablets, mobile phones :iphone:, smartwatches :watch:, TVs :tv:, and smart displays.

The list of devices with screens that need UX design is growing every day! :sweat_smile:

As you design across devices, you’ll need to consider the device’s screen size, the interaction between the device and the user, the way content will be organized on various screen sizes, and more.

To provide a great user experience across devices, keep in mind the four Cs:

  • Consistency : Having a uniform design, so users can expect the design to feel familiar across devices and products

  • Continuity : Providing users with a smooth and uninterrupted experience as they move between devices

  • Context : Designing for the needs of a specific device and the way in which the user will use that device in any given situation

  • Complementary : Taking into account how the product design on each device can make the overall user experience better


100daysofcode - Day55

Hi everyone :wave:, hope you are having a great day :smiling_face_with_three_hearts:.
Let’s wrap our day with learning about designing for mobile first after we finished discussing yesterday about designing across devices. :iphone: :point_up_2:

Design for mobile first :iphone:

Mobile first is a design philosophy that seeks to start the design process with the mobile version of a product and later adapt it to fit larger screens, like a tablet or computer. :iphone: :arrow_right: :computer: :arrow_right: :desktop_computer:

A mobile-first design philosophy is related to the practice of progressive enhancement , which is designing for the smallest and most basic version of a product before creating larger, more complex versions. By starting with a small screen size, designers have to choose the most important elements to prioritize on the screen. :1st_place_medal:

This approach contrasts with graceful degradation , which is designing for a larger screen with a lot of features and interactions first, then scaling back the designs to fit a smaller screen.
:desktop_computer: :arrow_right: :computer: :arrow_right: :iphone:

Benefits of designing for mobile first :grin:

  1. Access to the internet :globe_with_meridians:
    More people than ever are using mobile devices as a primary means of accessing the internet. According to the World Advertising Research Center, by 2025, 72% of all internet users will use smartphones as their only method of accessing the internet. A large portion of these users are the Next Billion Users , who are the people around the world who are starting to use the internet for the first time, often through mobile devices. The content, interactions, and features of products you design need to be accessible for the Next Billion Users, so a mobile-first philosophy is key.

  2. Reduce load time :hourglass_flowing_sand:
    Mobile-first designs help users quickly access content because fewer elements and features have to load. This is important because mobile phones don’t have as much computer power as desktop computers do. If you design for a larger screen size first, it can be difficult later to incorporate all of the design elements of a complex screen into a smaller one without impacting load time.

  3. Prioritized Content :trophy:
    Mobile-first design forces website designers to prioritize information. Since you don’t have much space, you need to pick and choose only the most important content to include. This helps you eliminate fluff that only bogs down your website and distracts users. It’ll make your website designs cleaner, more efficient, and more concise. In practice, mobile-first design makes you a better website designer.