Be a better UX designer by understanding development aspects

This lecture highlights the importance of sketching and visual thinking. We also included a list that summarizes why sketching is great for collaborative activities and ideation.

The 2nd part of the sketching and visual thinking lecture is about visual metaphors. These can come in handy during a designer-developer collaboration, since these can make otherwise complicated concepts more comprehensible. By watching this lecture, you'll understand how you can create and combine visual representations effectively. Next to these, the lecture lists out how sketching can be utilized during a product development process. 

Giving and asking for meaningful feedback might seem to be an obvious or straightforward activity. As you'll see after watching this lecture, there are some many guidelines you should consider following! Good feedback results in better design and development choices, and better choices ultimately lead to better work. 

The 2nd part of the giving and asking for meaningful feedback lectures contains some more guidelines, and we also included a practice activity for you!

This lecture underlines the importance of having a common language with developers. We can always apply visual language and visual thinking, however, it's also a good practice to ask honest questions about things you don't fully understand, and you should communicate in a way that it's jargon free and easily understandable.

You should involve developers right from the start, it's pretty self-evident. But how can they contribute effectively? What does the term "technical constraint" really mean? This lecture answers these questions.

This lecture is the second part of the project kick-off lectures, and it lists out the main technical constraints. Naturally, it's not your job to figure out an answer for these possible limitations, but you should know this list so that you can support your developer team members during a stakeholder interview or during a project kick-off meeting (workshop). By watching this lecture, you'll walk away with a comprehensive checklist of the most important constraint types.

Prioritization is an essential and ongoing activity during a product development process. And while some might think that prioritization is only about features, it's quite the opposite. You should focus on outcomes and impact instead of shipping features with great velocity. This 1st part explains some related concepts (e.g. feature creep / feature fatigue), and also contains some advice for you.

The 2nd part of the prioritization lectures summarizes these prioritization approaches: lean UX method, user story mapping and Intercom's method. More specifically, the lecture is about how you can collaborate with developers while applying these methods.

Involving developers in research activities is vital: it helps them build empathy for the users, but there are many more advantages, if you watch this lecture, you can learn about these. This lecture also gives you a high level overview of some research methods, and the ways you can involve developers. For instance in case of a user interview, you can ask a developer to act as a secondary interviewer. 

The 2nd part of the research lectures is about synthesizing research. In other words, you gather all the raw research data, and search for patterns. This "meaning-making" should be a collaborative team activity. Developers might have observed different things, e.g. identified obstacles or pain points you haven't noticed. In this lecture we mention several methods, e.g. empathy mapping, persona creation and storyboarding.

This lecture summarizes how developers can participate in an ideation process. More specifically, it explains conducting a design sprint together, and we also mention several other methods. Next to the theoretical knowledge, we're going to show you how we do a crazy 8 session, and we're going to ask you to try out this method, so there is a practice activity waiting for you! 

In this lecture, you'll learn what's the difference between fixed, fluid, responsive and adaptive layout.

In this lecture, we'll talk about responsive images, pixel density, and some more aspects concerning how to design for different devices.

This lecture contains some advice on how to achieve a good design handoff, how to hand over designs to developers effectively.

This lecture summarizes what the development aspects section is about, and why these topics are relevant for your design work. There is so much more to design than pushing some pretty pixels in Sketch or in an other design tool! By watching these lectures, you'll realize that a basic understanding of these topics is essential. As a result, you'll be able to make much more informed design decisions.

Architectures are basically application structures. Do you know how the application you are currently working on actually works? What is under the hood? Do you know what platforms are? This lecture explains all of these.

The 2nd lecture about architectures summarizes 3 different application types. Designing an online and an offline application is fundamentally different. In case of an online application, there is a client and a server side. You might ask why it is important for you. As you'll see, there are a lot of aspects that directly influence the users' experience.   

The 3rd lecture about architectures explains how offline applications work. We're going to demonstrate the mechanism through a note taking application.

The 4th part of the architectures lectures summarizes how online applications work. You'll see that tasks are split between the client and the server side. What you put on one side and what on the other should be an intentional design and development decision, since as you'll see, it directly impacts the users' experience. By watching this lecture, you'll also understand how Instagram manages to upload pictures instantly.

In the last lecture about architectures we discuss what microservices and microfrontends are. We know that these concepts sound complicated, but believe us, knowing about these'll make your collaboration with developers a lot smoother in many cases (especially if you work in a bigger organization).

There is a huge overlap between designers' and developers' mindset. Developers' work requires a special mindset, so if you understand how they think and operate, you’ll be able to better empathize and collaborate with them.

This lecture is an introduction to data types. Defining data types is about translating reality to computer processable format. While this topic may sound boring, you'll realize that defining data types is an important part of a specification, and it can be explained by talking about roller coasters, beer and a wardrobe :) (yes, we apply real life analogies to make it more interesting.)

This second lecture about data types summarizes what primitive data types are. We discuss these data types: logical (or boolean), numeric, character. How does it affect the users' experience? For instance if you choose an inappropriate numeric data type for a given currency, you might encounter problems when you localize that part of the app.

The 3rd lecture about data types explains what composite data types are. While the word "array" or "record type" might sound complicated, you'll see that these concepts'll help you design forms in a more complete way. Form validation is only possible if the required data types are specified for each form field.

Next to primitive and composite data types, there are data types with an additional layer of meaning. These are: date and time; gps coordinates and images. Have you ever wondered how the binary representation of an image looks like? This lecture gives you an answer.

As you'll see, for the purposes of designing an application, you'll need to combine the different data types. For instance, let's say we represent a user by using her name and date of birth inside an app, these are the two relevant aspects. It also means that for example her hair color is irrelevant, so we don't ask her about this information. Now, since we have more users, we should create "templates" for these two data pieces. You'll get why it is important after watching this lecture.

The abbreviation "JSON" stands for JavaScript Object Notation. Don't worry, this lecture is not about teaching you how to code! You'll see that understanding JSON is not that hard, and it's going to be a really useful skill for you, for instance you'll be able to interpret specifications written by developers.

The 2nd lecture about programming summarizes the concept of variables. This particular lecture clearly demonstrates the power of using visual metaphors: we're going to explain the concept of variables in a way that you'll instantly get it! The lecture also contains a real life example of using variables: we're going to take a look at a sign-up flow inside a web application.

If you've ever designed user flows, understanding algorithms won't be that hard! An algorithm is just a set of computer-executable steps designed to solve a problem. It processes input data and produces output data. By the end of this lecture, you'll understand what algorithmic thinking is about.

The 4th lecture about programming takes a look at what programs are, how they work. We demonstrate it by analyzing a form validation algorithm. If you watch this lecture, you'll get a basic understanding of how programs work - we even mention the concept of loops, so that you can dig deeper if you are further interested in this topic.

This lecture'll help you navigate in the sea of the following terms: programming language implementation, framework, run-time environment, platform. As a result, you'll know what developers are talking about when they mention or refer to these concepts. For instance you surely know that Android and iOS are platforms. But what about the other terms? Can you apply them in a confident way?

Applying an existing solution (a reusable component) instead of writing custom code significantly impacts the feasibility of a project. This lecture explains what reusable components are through a map component example. By watching this lecture you'll know what are the most important things to consider in connection with using an existing solution.

The 2nd lecture about reusable components highlights the importance of customizability. You need to check whether a certain existing solution supports customization or not, and if it does, to what extent. This lecture summarizes the 3 levels of customization, so next time your team considers applying an existing solution, you'll know what to pay attention to in terms of customizability. 

The two most common types of reusable components are libraries and services. These add additional functionalities to our software product. Again, we're going to use real life analogies to make these concepts more comprehensible for you. After watching this lecture, you'll know what the main differences between libraries and services are.

The abbreviation "API" stands for Application Program Interface. In this lecture, we're going to explain you this concept by two detailed examples, and as always, an exciting real life metaphor'll help you understand what an API is about (this metaphor involves ordering a pizza, so you'll surely like it). 

Data modeling us about representing real life concepts inside a digital product or service, and it is a process of choosing and designing effective storage solutions for our data, so that programs running inside our applications can work with it. This lecture is an introduction to data modeling, for example it lists out many-many answers to the "why should I care about this stuff?" question.

A conceptual model is a tool for defining reality in a way that you can translate the components to data structures. We believe that this is one of the most exciting lectures in the development aspects section, after watching it, you'll think about digital products or services in a more systematic way, and you'll realize that even the most complex systems can be broken down into entities, activities and relationships. 

In this lecture we're going to show you some possible designer - developer conversations about data modeling, so we're going to illustrate how the designer - developer collaboration might look like on this aspect. After watching this lecture you'll surely understand why this data modeling topic is relevant for a designer.

After creating a conceptual model, you can start working on the next layer, that is the logical data model. To put it simply, it's a more detailed version of a conceptual data model. We're going to show you examples (e.g. how this looks like in case of a boardgame event organizer app), and we're going to give you an exciting practice activity, you'll map out relationships between entities for a design studio finder app.

There are two common database types: relational databases and NoSQL databases. This lecture summarizes the main aspects of using relational databases. We're going to guide you through a very detailed example so that you'll understand everything you need to know about this concept in an easily comprehensible way!

As we mentioned earlier, there are two common database types: relational databases and NoSQL databases. NoSQL stands for “Not Only SQL”. After watching this lecture you'll understand what the main differences between these two database types are, and why this distinction is important from a UX perspective. Instead of talking about complicated concepts in an abstract way, this lecture summarizes using NoSQL databases by explaining 4 different use cases (e.g. a news website and a restaurant recommendation app). 

This lecture explains the concept of data concurrency and data consistency (as you'll see, these are very important in cases where the application uses the users' balances, so if transactions are involved). After watching this lecture, you'll also have a list of the main design making points concerning logical data modeling.

In the lectures about implementation we’re going to walk you through some important steps of the implementation of a note taking app we use as an example app throughout the course. You’ll get a clear picture of the process and all the relevant aspects, for instance we’re going to talk about version control and automated tests.

This lecture is a guided tour, we're going to walk you through the most important parts of Gitlab, so that you’ll see the version control concepts we’re talking about in context. Understanding how Gitlab works, and learning its terminology'll help you use other version control tools as well, for instance Abstract.

We believe that instead of just talking about theory and abstract things, you should see how things really work inside Gitlab, how designer - developer collaboration actually looks like. Therefore, we're going to walk you through 3 example situations in the following two lectures. This lecture contains the first example.

As we mentioned in connection with the first example (the previous lecture), our goal with these two lectures is to show you how things actually work inside Gitlab, how team members collaborate, what they can do using this application, how they notify each other, how they leave comments and so on. This lecture contains 2 more examples.

This lecture explains some more concepts about version control, and provides you a short summary of this topic. Next to these, it also contains a little practice activity.

This is one of the most exciting lectures, since it is about all the pieces coming together. You'll fully understand why we discuss architectures, data types, programming, reusable components, APIs and data modeling. It's like completing a complex puzzle! Next to this, the lecture illustrates that even in case of a really simple note taking app, there are so many design and development decisions you should make together with your team. 

The last lecture about implementation showcases the different collaborative activities during implementation. It also explains what automated tests are, how you should conduct usability tests together with the developers, and it summarizes how you can report bugs in a highly effective way.

This lecture contains a coupon code for the Sketching for UX Designers course and some recommended readings, useful links.