by jakob.schnurrer -

First literature Research – Impulse #4

The last three blogposts where all about my intentions and the reasons for picking open source as the topic of my masters thesis, this one is about first steps, I took in researching about open source and how this influenced the next steps, I want to make.

During the “Proseminar Master Thesis” course, we were tasked, to gather some sources we could use for our thesis in the future. Two books and an article. Skimming through those texts really changed my view on open source. Especially the impact of UX work on open source projects interested me.

1. Working in Public

Reading Working in Public felt like having someone open a curtain. I always knew open source was built by volunteers, but the book made me understand just how much work, coordination, and emotional labor goes into maintaining a project. I was especially struck by the part that explained how most projects start small and private, and how everything changes once people begin to use them.
The sections on hidden costs and funding were honestly eye opening. Until now, I never really questioned how open-source creators manage to keep projects alive despite having almost no resources. This book made me more aware of why people burn out, why documentation suffers, and why newcomers have such a hard time finding their place.

2. Producing Open Source Software

Where Working in Public explained what is going on, Producing Open Source Software finally gave me how. This book was far more structured, and honestly much easier to navigate. For the first time, I read concrete advice on where design can fit into an OSS workflow, especially the points about improving documentation, lowering the “activation energy,” and funding dedicated UX roles.
The most influential part for me was the idea that newcomers should write beginner tutorials. That simple thought made me reflect on my own homelabbing struggles: of course the docs feel hard, because they’re written by experts.
This shifted my thinking from “What UX problem should I research?” to “Maybe the onboarding experience of designers in OSS is the problem.”

3. Untold Stories

The third text, Untold Stories, finally backed many of my assumptions with research. UX professionals do help OSS projects. Their contributions are valuable. And still, hardly any of them participate.
The paper helped me understand why: the culture, the tools, the developer-first mindset.
What surprised me most was how differently UX people write issue reports: more factual, more user-centered, more structured. It made me think that maybe designers don’t need to force themselves into OSS spaces—they just need to show the value of this way of communicating.
It also strengthened my idea that UX needs its own “space” within OSS—something that current platforms don’t provide.

Accompanying Links

Link to the book “Working in Public” (sadly no free download): https://press.stripe.com/working-in-public

Link to the book “Producing Open Source Software”, which is free to download: https://www.producingoss.com

Link to the article “Untold Stories”: https://dl.acm.org/doi/10.1145/3706599.3720063

Ai was used to formulate this blogpost (ChatGPT)

by jakob.schnurrer -

Voluntary Service & Open Source- Impulse #3

Continuing from the last blogposts, where I talked about what got me interested in open source as a master’s thesis topic: homelabbing. In this post, I want to talk about an intrinsic motivation, that kept me moving towards this.

Voluntary work is part of my day to day life. Since 2014, I have been part of the scouts, first as a child now as a guide. Once a week I run meet-ups for children form 7 to 10 years old, where we go out into the forest, play and teach them to be come a valuable part of society. Doing work like this takes much more time, than one would think, there is planning those 2 hour sessions, preparing before the kids come and cleaning up after they leave. There are weekend camps and a big summer camp to organise, the groups home needs to be tidy and there even is a course a scout leader must take, learning about communication and pedagogy. I give a huge part of my free time to the scout movement, and all for no pay.

In addition to big voluntary movements like the scouts, there are small communities like the “UX Graz” Community, which organise a meet up for people interested in UX design, every third Tuesday of the month. Everything is organised and run by volunteers. Every meet up is held at a different company, which provides the location, food and drinks, and there are two parts in every meet up, first there are some talks and second networking. For people attending it is completely free. Free food, free drinks, free knowledge transfer and free new contacts. (I have recently joined the organising team swell, so this is my second voluntary work.)

In my mind, there are a lot of parallels between voluntary work and open source. A small amount of people does work or creates something, that benefits a lot of others. And the work these people do is often overlooked. They act in the background often earning nothing more than respect and thanks from others. Especially in these times, it is hard t have a job, that doesn’t pay you money, next to your regular day job. Due to different reasons most people cant’t afford to work for free, still there are a bunch of people who do.

I hope to find a reason for people to work for free. In my opinion voluntary work provides a lot to society. Although sometimes I feel like the work volunteers do is under appreciated, especially youth organisations. Although to be fair, open source doesn’t mean free and open source projects aren’t always maintained by volunteers who aren’t getting paid. What drives people to give away their product for free? How can the value of voluntary work be communicated? Looking into the psychological and social aspect of people doing work just for the benefit of others, is something I would want to get into more.

Accompanying Links

A link to the UX Graz Meetup: https://www.meetup.com/uxgraz/

A link to the website of the Austrian scout movement: https://ppoe.at

by jakob.schnurrer -

Hosting Applications (Homelabbing_2) – Impulse #2

In my last blog post I wrote about my first steps in homelabbing, to clarify in homelabbing you try to setup a home server environment to run services, test and learn new stuff. Some examples: Host a cloud service, a picture backup service, a home NAS (Network Attached Storage), your own streaming service or even a Minecraft server. I set up a “home server” an old laptop got it a new operating system and installed the first services.

After this first success, I felt ready to dive deeper. To really host a service, that I can use, maybe even outside of my home network. And the first thing, that came to my mind was a Minecraft server. My cousin had done it, other friends had done it, so it can’t be that hard. And it really isn’t. The documentation is good, all in all it’s just installing java & the basic server run file. I just had one issue, which was exposing a port to the internet, which I could solve after a while of searching through forums. (I ended up finding the answer in the docs, just not where I looked.)

Now, I had used the terminal, I had a service running, why not set up something that I can use in a more productive way? And this one, didn’t go so well. See for a lot of the services most people run on their homelab you need a separate software for them to run properly, most of the time that is Docker. In short, Docker solves the “It works on my machine…” problem, a lot of new software has. (Here is a Network Chuck tutorial explaining Docker in more detail: https://youtu.be/eGz9DS-aIeY?si=aSPVoBCwRwZ6zaLs) It basically creates the perfect environment to run a certain piece of software. And just getting that to work, took me a while, reading documentation, forums, watching video tutorials.

After I had setup Docker and it was running properly, I decided to install a Remote Desktop application, so I could make changes to my home server from where ever I wanted, without having to use the old laptop to do so. I planned to hook it up to my home network and leave it running, without having to open it up to make changes. Through a Reddit post I discovered RustDesk, an open source remote access software, which can be self hosted through Docker. And for the first time, installing a new service just worked. The Docs were easy to follow and in less than an hour, I had RustDesk running.

After this first success I really wanted to have a service running, that would provide a benefit to my day to day life. Three different ones really caught my eye: PiHole, a network wide ad-blocking service, Immich, a Google Photos like picture backup cloud and n8n, a patching tool similar to Max that let’s you create Ai supported automations. (I provided Links to the projects below)

Sadly It was not all fun and games. Like all good homelabbing projects I ran into another problem, which had put this whole experience to a hold. Everything I had done until now ran through the W-Lan of my apartment, which is suboptimal, it clogs up the WiFi for other mobile devices and is slower, compared to a wired connection. Since I planned to put the server somewhere in the apartment and never move it again, I wanted to hook it up immediately. This lead to the laptop not booting, so I couldn’t do anything while it was hooked up to the network, but it would work fine when I unplugged it.

Impact for my Masters Thesis

Thinking back now, when I tried to set up Docker, this actually was my first encounter with a big problem in open source: Bad newcomer onboarding and difficult documentation. As I would find out later, during deepening my research in open source, this is also one of the areas that experts see the most use for UX work, creating an easy to understand onboarding and easy to read documentation. It’s a hit or miss. Sometimes it takes hours to troubleshoot a problem and reading through forum posts, to find the solution, that works for you.

What still stuck with me this whole time, thinking about open source, was the thought of coming into a new area or hobby and trying to solve a problem I don’t truly understand. I have used open source software before, I read docs and learned a lot, still finding a research question or a problem to solve is hard. I guess I need to dive deeper into this whole field to truly understand it. Everything I thought about felt strange, a new person coming in and trying to solve a problem that they read about in some forum or book. This lead me more into the direction of documenting, how to contribute as a designer in the first place or how to run/ start an open source project, since I really like the way of providing a product for others to use and change, best case for free.

Accompanying Links

Here are some links to the different services I mentioned im the blog post:

https://rustdesk.com

https://minecraft.wiki/w/Tutorial:Setting_up_a_Java_Edition_server

https://n8n.io

https://immich.app

https://www.docker.com

https://pi-hole.net

by jakob.schnurrer -

Reinstalling (Homelabbing_1) – Impulse #1

Quite a while ago I found an old laptop at my parent’s place. A very old machine, I used back when I was like 15 years old. Not very flashy but at that time a good device to do what I needed to do, which was school work and playing Minecraft. At that time I was really into home automation, doing things myself, creating my own NAS (Network Attached Storage) or hosting other applications. So after getting my old Laptop, I started to test some stuff. The first thing, I noticed was that the laptop was very slow. I don’t know what 15 year old me did to that thing but it sure wasn’t the best for the hardware.

After doing a little research, on how to breathe life into an old laptop, I stumbled across Linux. For those who don’t know, Linux is a light weight open source, mostly free, operating system. Just like Windows or MacOS. And let me tell you, choosing the right Linux distribution to run on my machine was another rabbit hole, since there are so many. There are ones optimised for hacking, or to look like MacOS, or to be very light weight (ArchLinux). In the end I decided to use the most common Linux “Distro” (short for distribution): Ubuntu. Which is supposed to give me a similar experience to windows and is one of the most widely used Distros. (Which comes in handy, when trying to troubleshoot anything, since someone most likely already fixed that same problem.)

Next steps included, going through old data and clearing out old junk, erasing all data and installing a fresh installation of Ubuntu. And I got to say getting to this point too a while, but after the laptop booted into the home screen of Ubuntu it felt great! But what to do now? One of the “simplest” thing I could think of was trying to connect the laptops storage to my home network, so I could use the old guys storage capacity to exchange data from one device to another, without plugging in an USB stick, or saving backups of very important data. To accomplish this, I used Samba (another open source project), which let me expose a folder to my network. Setting this up took a lot of trail and error, as well as a lot of terminal commands. But now I can get data from my MacBook to my Windows PC without attaching and detaching anything.

Starting this project was a lot of fun. A bunch of new things to learn and new possibilities arise. After this first success I got a bunch of other ideas which I could now host on my own, a cloud service, a Minecraft server or a google photos like application to save and share pictures.

Impact for my Masters Thesis

But what does this have to do with my masters thesis? A lot of the software used when creating a home lab is free and open source. Additionally the freedom to host your own services for free, because someone created free software for you to use, is great! Nevertheless it is a fun project, to get into computers and hosting one’s own cloud service feels great and has a lot of advantages (and disadvantages).

All those possibilities got me thinking, why and how do people create software used by thousands and millions of users? What drives open source projects? How are they financed? So in short this was the start of my interest in open source and the reason, why I want to dive deeper into this topic in my masters thesis. I am sure, there is more to uncover, to try out and to learn.

Accompanying Links

If you start to build your home lab, there is a bunch of stuff you need to know about and Network Chuck provides an amazing overview of most relevant topics. From explaining Linux to n8n (an Ai automation software) to hosting your own NAS. The videos are easy to follow and beginner friendly, in other words the perfect start for newcomers.
Here is a link top his YouTube channel: https://www.youtube.com/networkchuck

When trying to do anything on Linux you will need to use the terminal. Installing apps, bluetooth doesn’t work, advanced settings. open the terminal. As a beginner, I didn’t understand what I was writing in this text input. So I used this website: https://explainshell.com/# (another open source project), that explains every command that is put into the terminal.

The last link I want to share is the website of samba, the software I used to open up a folder to my home network. As they say on the website: “Samba is an important component to seamlessly integrate Linux/Unix Servers and Desktops into Active Directory environments.”
https://www.samba.org

by jakob.schnurrer -

Evaluation of a Master’s thesis

Autor: Matthias Müller, BSc
Titel: Applying Service Design on Free Open Source Software (FOSS)
Erscheinungsjahr: 2017
Hochschule: Graz University of Technology
Master: Software Development and Business Management
Quelle: https://repository.tugraz.at/publications/yq1qq-qwe76

This master’s thesis takes a closer look at how open-source software projects actually work. While open-source tools are built “by users, for users” and have changed the tech world in many ways, their success often depends on more than good code. The author uses service design methods to explore the Austrian open source project “Catrobat”, mapping everyone involved, their roles, and how they work together. The goal is to find out what helps or holds back open-source projects and how better collaboration and understanding can lead to more innovation long-term success.

Presentation quality 

Overall, the master’s is well made, the layout is simple yet fitting, since the layout itself probably wasn’t part of the scope. Simple paragraphs, some graphics and pictures, highlighted quotes, nothing special, although you could find some gaps in the text due to the full justification. Long, bloated sentences and swollen language make the text difficult to read. But the arguments made follow a logically form, from explaining the open-source context to applying service design tools.

Degree of innovation & independence

What stood out to me is how service design is connected to the world of open-source software, since any design practices are usually hard to be implemented into open source projects. The work shows a high level of independence, especially in how the author adapts existing design tools to fit the unique dynamics of Catrobat. Although making assumptions for the whole world of open source might be a bit farfetched, since open source projects can be very different, not only in size but number of users, supporters or funders, distribution channels and much more. Meaning this is a great case study but doesn’t really contribute to making the open source more design friendly.

Organization and structure 

The thesis is well structures, although sometimes hard to understand. The author is very thorough, service design & Catrobat are both very well defined and explained. Before using a service design tool, the author explains the reason for using it first, explains the process, shows the results and their conclusion in the end. The flow of the work seems natural, and additionally the usage of graphics and pictures, as well as bullet points really help to clarify.

Communication 

Like I have said before, the language is hard to understand, or in other words very academic. However, this might just be due to my background being in design and not more science driven studies, like computer science or information technology. In the eyes of a student of the technical university of Graz, the tone might be common.

Scope 

The topic is handled with an appropriate level of detail overall, although personally I would have pot emphasis on different topics, as the author did. Catrobat is explained in a lot of detail, while user research or testing of proposed improvements fell short, although those are key elements of servicer design.

Accuracy and attention to detail 

Citations are well made, if they are taken word by word, they are visually different from the rest of the text. Footnotes as well as inline citations are flawless and all figures are accurately described. I also couldn’t find any grammar or spelling mistakes, luckily writing software like microsoft word gets better at catching those mistakes.

Literature 

The literature review is solid, with relevant sources from design, service research, and technology studies. It combines classic design theory with more recent publications about open collaboration. The references are well integrated and show that the author understands the academic conversation around the topic

My personal reason to pick out a master’s thesis like this one was to get a better grasp on open source in general, since I want to write my thesis about the same topic, although with a different scope. I used this exercise to get more insight into the opinions of non designers working on open source software. But as I pointed out, grasping the topic and the conclusion was hard, due to me not being able to understand and comprehend the way sentences were written.

Disclaimer:
This blog post was supported by AI (ChatGPT) to help with structuring and phrasing.

by jakob.schnurrer -

16 Morse Code with Arduino Summary + Video

Over the semester, I built a simple Arduino-based Morse code prototype. It started with just three buttons to create Morse code messages, which were then turned into sound. I quickly realized that keeping it on one device didn’t make much sense, so I connected the Arduino to Wi-Fi and used OSC to send messages to my laptop. From there, I added a decoding function that translated Morse into readable text. In the final step, I built a basic web interface where you could type a message, send it to the Arduino, and see it displayed on an LED matrix. My idea is to use this setup to teach kids about encryption in a playful way. Along the way, I learned a lot about Arduino syntax, using libraries, and how to build Wi-Fi and web-based interfaces—opening up tons of new creative possibilities for me.

by jakob.schnurrer -

15 Creating a Web Interface for Arduino

Like I have teased in the last blog post, I came across a YouTube video, that showed, how to create a web interface for an Arduino. This has a number of use cases, live sensor monitoring, remote control, live system feedback or interactive installations. This makes it possible to control how the user can interact with an Arduino, using a platform, that they already know.

When the Arduino connects to a WiFi network, it gets an IP address and starts a tiny web server that can talk to web browsers. When you open that IP address in your browser, the browser sends a request to the Arduino. The Arduino responds with a simple web page, in my case a form in which you can write morse code. If you type something and click “Submit,” the browser sends the text back to the Arduino. The Arduino reads and understands the send information and can react accordingly. This way, the Arduino works like a tiny website, letting you interact with it through any browser.

I once again started with an example, I found in the WiFiS3 library of Arduino, “SimpleWebServerWiFi”. This code generated a very simple website with which you could turn on and off an LED on the Arduino. Using this as my starting point, I first wanted to expand the web interface, which took a little longer than it would usually take to build, since I had to upload the code multiple times and change it so it finally looked “good enough” for this prototype. But doing the interface it self was just the easy part.

Before
After

Next I wanted to give my simple interface some functionality, there for the form I created on the Arduino needed to send the data input by the user back to the Arduino, so it could understand and for now translate it. And I have to be honest, I really tried to understand the code but just couldn’t figure out, how it worked, so I asked ChatGPT to help me out. Using its infinite wisdom it created a short piece of code, that converted the users input into a string, that could be understood by the code, I had written before.

The next step was easy, I added the code for decoding the message, I created last week and explained in the last blog post. Now I just needed the Arduino to display the message, after it received one, which was easy enough by just adding an “if” statement, that would only add extra content to the website, if a message had been received before. And like that, I finished the next version of my chaotic morse code prototype.

Now that I’ve built this basic version, I’ve been thinking about how this kind of setup could be used in different contexts. For example, it could be adapted for interactive museum exhibits, where visitors can type a message into a browser on their phone and trigger lights, sounds, or physical movements in an installation. It could also be used for DIY home automation, like controlling lights. Or it might become a learning tool for kids, where they can experiment with inputs and immediately see results, helping them understand communication systems like Morse code in a playful, hands-on way.

Instructions

If you wanted to try it out yourself, here was what you needed:

  • An Arduino
  • a Laptop or any other device that can use a Browser ;D

This time it is even simpler, plugin the Arduino, change the SSID & Password to fit your home WiFi network and upload the sketch. In the Serial Monitor you will then see the Arduinos IP address, now open a browser and type in the shown IP address. Now you should see the simple interface I created, the only thing to do now is to write some morse code and let the Arduino decode it.

MorseWebServer.inoDownload
by jakob.schnurrer -

14 Adding encryption to Morse Arduino

After getting the Arduino to encode Morse messages and send them to a connected Max patch (see the last blogpost), I took the next step. So far, I built a way to create messages, and a way to transmit them, but not everyone was able to simply read and understand morse code, so the next step was obvious: build a way the messages could be read in clear text. The idea was simple: after every message got “sent”, the Arduino would take the Morse code string and convert it into readable text.

My first attempt was a long list of if statements, which worked, but I had hoped for an easier way to add and administrate different dot & dash combinations. Next I thought of using a switch statement to iterate through the combinations, but Arduino doesn’t support those, so I had to come up with a new idea. After searching on the internet, I came across a different solution, using arrays. So I rewrote it using arrays that mapped Morse code strings to letters. That gave me something that felt like a switch statement. It was now much cleaner, and easier to add custom combinations later.

Before:

After:

The decoding worked like this: one array was filled with all the Morse code symbols, and one with the matching letters. The code then iterated through the Morse message character by character, building a temporary substring that represented a single Morse symbol (like “.-” or “–“). Whenever it hit a slash (/), the program knew it had reached the end of one symbol. It then compared the collected substring to all entries in the Morse array. When it found a match, it took the corresponding index in the letter array to find the translation. That translated letter got added to the final decoded message string.

To figure out how many slashes were pressed, the code counted how many consecutive / characters appeared in the string. Each time it found a slash, it increased a counter. When a non-slash character came next (or the message ended), it used the number of counted slashes to determine the type of break:

  • One slash (/) meant a new letter started.
  • Two slashes (//) meant a new word started.
  • Three slashes (///) meant the start of a new sentence.
  • Four slashes (////) marked the end of the message. 

This system worked surprisingly well and gave me more control over formatting the final message. By using these simple separators, I could organise the output clearly and logically. Here is how the full print would look like with the translation.

The result? A very basic but fully functional Morse communication device: input, output, transmission, and now decoding. Currently it is just displaying the message in the serial monitor, but I plan to make the message be displayed on the LED Matrix, on the Arduino, that way the message is readable to the user immediately. I also read online, that an Arduino can be connected to a web server, so I will probably test that out, since this way I could create smart devices for my room on my own.

Instructions

If you wanted to try it out yourself, here was what you needed:

  • An Arduino (compatible with Modulinos)
  • The three button Modulino
  • The latest sketch with decoding logic (I could share this if you were interested)

Not a lot to do, except plugging in the three button Modulino and uploading this sketch:

MorseDisplayDownload
by jakob.schnurrer -

13 Adding UDP/OSC to Arduino

If you have read my previous blog post, the next step comes pretty natural. Just having one device creating and displaying morse code, defeats the purpose of this early way of communication. So I sat down, to set up a network communication between the Arduino and my laptop, which sounded easier than it was.

Since I had used OSC messages in countless classes before, I wanted to come up with a sketch, that could send those messages. Searching for a possibility to send this messages over WiFi, I started by looking at the examples, that were already provided by Arduino and I found something! Part of the WifiS3 library, there was a sketch, that showed how to send & receive UDP messages. Great! I uploaded the sketch and tried sending a message to the Arduino, using a simple Max patch. The message was received, although the response message wasn’t.

As you can see on the screenshot above, Max received a message, but it wouldn’t display its contents, since I had no idea what went wrong, I tried to adjust the message, so it would be a multiple of four, just like Max asked. But I just got another error message:

Still no idea what this error message was supposed to mean, but I kept trying. I reduced the length of the “message name string”, but without any success. I still got the same error message, as before, even though an even shorter message name wouldn’t have made any sense.

Defeated, I went to class the next day and talked about my problem with a fellow student. He brought to my attention, that Daniel Fabry had shared an example for the same thing last semester, which I knew worked, since I tried it in class, I just had forgotten about it. So I took a look at his sketch, which used an entirely different library. The code syntax was early identical, but the library was different. With my new knowledge, I adapted my code again and this time, it worked!

Now my Max patch could receive strings from the Arduino, great! As a next step, I updated my patch to actually replay the received morse code message. And my new version was done! Now messages could actually be sent wirelessly to other devices making actual communication possible.

This little detour into OSC & WiFi with Arduino really got me interested to explore this topic further. I am excited to find out the things that are possible using this technology.

Instructions

For the second version, you need:

  • an Arduino (capable of using Modulinos)
  • the three button Modulino
  • a Laptop with Max
MorseUdpDownload

Before uploading the sketch to the Arduino, you need to go into the “secrets.h” tab and enter your WiFi SSID (Name) and password. After this, go to the “sendIP” variable and change the Ip Address, to target your laptop. After applying these changes, upload the patch & build a simple UDP receive logic in Max, similar to the one you can see on my screenshots.

by jakob.schnurrer -

Jobs To Be Done (Workshop) – WebExpo Day 2

On day one, I visited a lot of different talks, one of them was “What is the ‘Jobs To Be Done’ framework and why should you care?” by Martina Klimesová. Looking back, this was a pretty biased talk about this framework, for beginners, still a great way to get to know the framework better. It actually got me so interested, that I joined her short workshop the next day, to try working with Jobs To Be Done myself.

In short, what is JTBD? The framework is based on the assumption, that people don’t simply buy products. They hire them, to get a job done, for example: People don’t want a drill, they want to hang a picture. The goal is to stop focusing on solutions. Depending, on the scope and context, there is hundreds of different jobs, a person wants or needs to do, to achieve a certain goal. But how do you get there?

The JTBD framework consists of five steps:

  1. Define the focus/scope of your project (start small)
  2. Talk to users – conduct interviews
  3. Analyse & Cluster your insight
  4. Define Jobs
  5. Create a Job Map

Defining the focus/ scope – During the workshop we focused on a small coffee stand, in front of a huge office building. The end goal was, to raise the profits of said stands to do that, we needed to conduct some research, to find out which jobs people need to do, on their way to work. Assuming, they would pass the coffee stand on their way to the office. So our focus was set, we wanted to analyse peoples “get to work routine”, from the moment they get up, to when they start work. In reality, you would base that decision, on business requirements, collected data or just gut feel.

Conducting Interviews – Next is to interview between six to twelve people, or better yet until you can see certain patterns repeating themselves. The focus of those interviews are the feeling of people, in a certain situation and their processes they go through, to achieve their end goal, in this case, getting form home to their workplace. Martina advised us, to take notes of our insights on sticky notes, since they were easy to rearrange in the later stages of the process. One Insight per sticky note. She even handed out a cheat sheet, to help with the process.

Analysis & Clustering – After conducting your interviews, you should end up with a bunch of sticky notes, with a lot of insights. The next step, is to cluster those insights in different groups, try to find a headline for each of the groups. For the coffee stand example those groups were: How people commute to work, what they eat, when they have their first coffee, how they deal with the weather and a few more, I can’t remember. Try to keep the clusters small and separate them into smaller groups, if they get too big.

Defining Jobs – After clustering your insights, try to find job statements for each cluster, this could be just one or multiple. The statements can be very specific like “Buying a coffee” to very abstract like “not feeling sleepy”. This is the hardest part of the process and it will take a while to get all the jobs down.

Creating a Job Map – This is the last part of the process and probably the most fun. After creating job statements and writing them down on sticky notes, now you put it all together. The goal is to create a timeline of jobs, people need to do to reach their end goal. The time line can be separated into multiple milestones, like “leaving the house”, “commuting to work” & “sitting down in the office”- You put down the sticky notes according to the point in time, the users have to fulfil them. Additionally you should separate abstract from specific jobs, you could create a scale, having the most abstract jobs at the top and the very specific ones at the bottom. This map should then be shared with your whole team.

If you want to know more, here is a link to the book Martina kept recommending (both during the workshop & her talk): https://www.amazon.com/Jobs-Be-Done-Playbook-Organization/dp/1933820683