Be A Better Ux Designer By Understanding Development Aspects

Stand out from the crowd, make more complete UX designs and better design decisions by understanding development aspects
What you'll learn
How to make better design decisions by understanding development fundamentals, technical constraints
Knowing what is going on inside the computer is essential for great UX design work
Understanding technical aspects will make you a better designer, even if you don't have the chance to collaborate with developers
Involving developers in your design workflow right from the start of the project adds a powerful new perspective to your UX work
Forget the "Should designers learn to code?" question, designer-developer collaboration is not about learning to code
How to get involved in developers' activities (e.g. during implementation: testing, bug reporting)
Understand the differences between online and offline apps, so that you can take into account users' needs and context better
How to represent real world objects & concepts inside a digital app (e.g. data types, data modeling)
Better form design: what you should specify next to UI specs (e.g. user input's data type, max. text length)
Learn algorithmic thinking so that you'll be able to consider all cases, spot redundancies, remove inconsistencies
How a form validation algorithm works, what the design implications are
Performance is an important limitation, and your design decisions always impact it! (e.g. designing web applications)
You should be involved in decisions about how to store data, e.g. you can tell what groups of data will be read or modified together and how often
How to define logical relationships inside an app, e.g. "a user can have maximum 1 profile picture" is a rule you should define
Design decisions affect risks, costs and development effort, e.g. custom code is usually more expensive than using an existing solution
How to choose an appropriate existing solution, reusable component (e.g. map component: Google Map)
How API's work, why you should know what functions are provided by a given API (e.g. in case of a payment solution)
How to ask better questions from developers, and how to educate them to ask better questions from you
Requirements
There are no requirements necessary to enroll.
Description
This course is about development fundamentals for UX designers & how to involve developers in your design processes.We won't teach you how to code, instead, we'll focus on all the topics, aspects you need to know in order to create designs that developers'll be able to build effectively. You, as a designer, contribute to a software development process. And without knowing what's under the hood, you won't be able to make informed design decisions.[Update: 0.5-hour new content added on 16th November, 2019 - Designing for Different Screen Sizes & Devices; Design Handoff Advice][Release date: 7th November, 2018]By learning about technical constraints and development aspects, you'll be able to include a valuable additional layer in your design work. As a result, you'll stand out from the crowd, you'll be able to provide a more complete, more intentional design to your clients (whether you are a freelancer or an employee). Here are some of these aspects you can and should include: Let's say users can upload pictures inside your app. But how many pictures can they upload? Or let's say you design a form. You should specify the max. length for each text fields, otherwise the user input displayed on a UI - e.g. a username - might break the layout. Or what happens if two or more users modify e.g. the price of a product simultaneously, how this conflict should be resolved? Another aspect is that based on the users' context, what application type should you choose, an online or an offline app would support user goals better?These are all design decisions, and if you don't make them, someone else will do, so if you want to design a product or service intentionally, you should consider these aspects. It is even better if you can make these decisions together with developers. Their unique, specific perspective'll complement your interpretation and point of view. So next to considering and incorporating technical aspects during your design work, it's also great to collaborate with developers right from the start of a design process. You should involve them in UX research and ideation (e.g. design sprint, storyboarding) activities. Likewise, you should participate in their workflows, for instance during implementation, you should follow their progress inside a version control software, help them write automated tests and regularly test out what they built. To sum up, the course has two main goals.1. We teach you the main technical constraints and development aspects.Understanding these is beneficial for any designers, whether you are a freelancer or an employee.2. You'll learn how to collaborate with developers. We'll teach you how you can involve them, how you can ask better questions from them, and how you can participate in their workflows.Learning how to collaborate effectively is beneficial for designers who work in a team or collaborate with others regularly.The two goals are closely connected: understanding development aspects will help you improve the way you work with developers. The course has 4 parts:Foundation: By watching this section, you'll understand how design work is incorporated into a digital product development process (e.g. waterfall, agile, lean)Being On The Same Page: Without having a common language, you can't collaborate effectively. By watching this section, you'll learn how sketching and visual thinking helps you establish a shared understanding with developers.Design Aspects: Involving developers in your design workflow right from the start lets you include a unique, additional perspective in the process. Thanks to this section, you'll learn about the main opportunities for involving developers, e.g. conducting UX research together; ideating together (e.g. design sprint)Developments Aspects: To design and implement a digital product or service in a way that it matches users' needs, you must know what is going on inside the computer. We'll teach you the most important aspects in this section.If you are a UX designer / interaction designer / product designer / service designer / UI designer (your label doesn't really matter), most probably you are working on digital product or services. In other words, you are creating software products. Learning about the different development aspects is not only about making a product development process more efficient. It's so much better to work in an organizational culture or in a cross-functional team where you can concentrate on doing your best work! Your team members'll appreciate that you understand the risks, costs, trade-offs of a design decision, a request, and as a result, a mutual trust can be established.This mutual trust means that developers know that you won't ask for an unreasonable modification, and you'll also know that they'll be transparent about their processes and about the amount of development effort required to complete a task.As you'll see, involving developers in your design processes, and asking developers to involve you in their processes results in an effective cross-functional collaboration. Product development processes have evolved in a way to reflect how technology and users' expectations have changed. Now we can get user feedback from the market really fast, and based on that feedback, we can continuously improve and fine-tune our digital product or service, in other words, we apply continuous integration and continuous deployment. To be able to work in this environment, we need cross-functional teams creating software products in close collaboration. And even if your organization still uses a waterfall process, you'll learn a lot about how you can take into account development aspects during your design process, how you can create a better design hand-off.About the course material:We created more than 50 hand-drawn sketches to explain the otherwise complicated concepts in a digestible, comprehensible way - you can download all these sketches in high-resolution!We included a many practice activities so that you can solidify your understandingYou'll also find a walkthrough of GitLab's interface - knowing about how version control systems work helps you participate in implementation activities; and since version control tools created for designers apply the same concepts and terminology, this guided tour'll help you use these tools, for instance Abstract.While we won't teach you how to code, thanks to the lectures about algorithms and programming, you'll understand all the basic concepts that are actually prerequisites of programming. Therefore, you can use these parts of the course material as a litmus test: if you particularly enjoy those parts, maybe programming is for you. But we believe that the infamous "Should designers learn to code?" question is irrelevant. If you want to learn to code, go ahead and start learning it. However, what is truly relevant is that you should understand how developers work, what challenges they face, what their main tasks are. This course'll teach you all these.We have also included the related UX Knowledge Base Sketches, you can also download these in high-resolution.The course videos are optimized for full HD resolution[select 1080p (or "Auto") resolution at the bottom left corner of your streaming player if it is not set to that resolution automatically]. If for any reasons (e.g. slow Internet connection) you can't access the videos in full HD resolution, we attached all the sketches in high-resolution, so you can print them out and follow the lectures by using the printed material.Stay tuned for future updates! We're planning to add new lectures soon, e.g. about Responsivity (designing for different screen sizes and devices); Internationalization & Localization; Security and Cryptography.As a result of watching these lectures, you'll be a more confident designer, who knows what making intentional design decisions mean.
Overview
Section 1: Foundation
Lecture 1 Before We Start Our Journey...
Lecture 2 Product Development Processes - Part 1
Lecture 3 Product Development Processes - Part 2
Lecture 4 Product Development Processes - Part 3
Lecture 5 Roles and Core Competencies
Lecture 6 Collaboration: Main Areas
Lecture 7 Collaboration: Best Practices
Section 2: Being on the Same Page
Lecture 8 Sketching and Visual Thinking - Part 1
Lecture 9 Sketching and Visual Thinking - Part 2
Lecture 10 Giving Feedback - Part 1
Lecture 11 Giving Feedback - Part 2
Lecture 12 Speaking the Same Language
Section 3: Design Aspects
Lecture 13 Project Kick-Off - Part 1
Lecture 14 Project Kick-Off - Part 2
Lecture 15 Prioritization - Part 1
Lecture 16 Prioritization - Part 2
Lecture 17 Research - Part 1
Lecture 18 Research - Part 2
Lecture 19 Ideation
Lecture 20 Designing for Different Screen Sizes & Devices - Part 1
Lecture 21 Designing for Different Screen Sizes & Devices - Part 2
Lecture 22 Design Handoff Advice
Section 4: Development Aspects: Introduction and Architectures
Lecture 23 Development Aspects: Introduction
Lecture 24 Architectures: Introduction and Platforms
Lecture 25 Architectures: Application Types
Lecture 26 Architectures: Offline Application Example
Lecture 27 Architectures: Online Application Example
Lecture 28 Architectures: Microservices and Microfrontends
Lecture 29 Developer Mindset and Developer Types
Section 5: Development Aspects: Data Types
Lecture 30 Data Types: Introduction
Lecture 31 Data Types: Primitive Data Types (Logical, Numeric, Character)
Lecture 32 Data Types: Composite Data Types (String, Array, Record)
Lecture 33 Data Types: Date, Time, GPS Coordinate and Images
Lecture 34 Data Types: Combining Data Types
Lecture 35 Data Types: JSON
Section 6: Development Aspects: Programming
Lecture 36 Programming: Introduction
Lecture 37 Programming: Variables
Lecture 38 Programming: Algorithms
Lecture 39 Programming: Programs
Lecture 40 Programming: Application Environment
Section 7: Development Aspects: Reusable Components
Lecture 41 Reusable Components: Introduction: A Map Component
Lecture 42 Reusable Components: Customization
Lecture 43 Reusable Components: Libraries and Services
Lecture 44 Reusable Components: API
Section 8: Development Aspects: Data Modeling
Lecture 45 Data Modeling: Introduction
Lecture 46 Data Modeling: Conceptual Modeling
Lecture 47 Data Modeling: Designer - Developer Conversations
Lecture 48 Data Modeling: Logical Modeling
Lecture 49 Data Modeling: Relational Databases
Lecture 50 Data Modeling: NoSQL Databases
Lecture 51 Data Modeling: Main Decision-Making Points
Section 9: Development Aspects: Implementation
Lecture 52 Implementation: Introduction
Lecture 53 Implementation: Version Control and Gitlab
Lecture 54 Implementation: Gitlab Example 1 (Wireframe Review)
Lecture 55 Implementation: Gitlab Example 2-3 (Build & API Review)
Lecture 56 Implementation: Version Control: More Aspects and Summary
Lecture 57 Implementation: The Pieces Coming Together
Lecture 58 Implementation: Collaboration in General
Section 10: Bonus Lecture
Lecture 59 Bonus Lecture: Coupon Code & Recommended Links
UX Designers,Interaction Designers,Product Designers,UI Designers,Service Designers,Web Designers,Freelance designers,Designers working at an organization (whether it's a startup or an enterprise),Any designer who wants to learn about how developers work, and how to ask better questions from them,Anyone who wants to improve the workflow of creating digital products and services (apps, websites, systems),This course is NOT for you if you want to learn how to code! This course is not about coding!,This course is NOT for you if you are expecting a detailed, step by step walk-through for creating a digital product or service from the first stroke all the way to the first release! This course concentrates on development aspects, technical constraints, and designer-developer collaboration.
Screenshots

#