Winter is coming, so it's a good time to take care of the heating in our homes. In this post, I will show how I built a complex heating system for my home using Home Assistant. I also have a secret agenda 🙈 It's to share my thought process when approaching an automation problem that looks complex.

In this blog post, you will learn that you can build complex automations by combining two things:

• Planning upfront what you want to achieve
• Breaking down the automation into smaller, simpler parts

The outcome

Let's start by the end. Let me "sell" you what I created so that you want to continue reading 💪🏻. ️

My heating system is granular per room, each room has a standalone heating mode that can be:

• Present
• Absent
• Vent

Each mode (of each room) has a different target temperature based on the official French energy savings recommendations.

The heating mode is automatically set based on a few factors:

• Presence in the room
• Ventilation of the room (It's a fancy term to say "Windows open")

If I am working in my office, only my office will be set to Present, and every other room will be set to Absent. Rooms with the windows open will be set to Vent.

Basically, the heat follows me. I heat only what's necessary.

I can also override anything manually, without going to Home Assistant. I just walk to a radiator, turn the valve and the room goes into override for a specific amount of time (In my system: One hour).

Helpful, but never in my way.

If one day I am sick and cold while going to bed, I don't want to fight with my house to get heat.

I also have other specificities for specific rooms, such as a Boost mode in my bathroom that automatically triggers when I take a shower based on humidity. I won't go into all the little detail in this post, simply because I won't need to. We're going to focus on a single room, but the same thought process was used in every room. Sometimes inputs slightly vary from room to room, but the principle stays the same.  

Hardware

Let's not get fixated too much on hardware, I think what I created could work with almost any hardware available. I do not own fancy stuff.

Heating

I have a gas boiler. It's connected to a smart thermostat. Mine is a Netatmo.

Each radiator has a thermostatic valve, I stayed on the same Netatmo ecosystem

They all work the same way. The thermostat controls when the gas boiler heats or not. The thermostatic valves open or close based on the room temperature.

By default, these systems are usually set in a mode called Eco (Or similar). In this mode, only the thermostat can request heat from the boiler. So if the room where the thermostat is located is "warm" (It's usually in the main living space) and you set the thermostatic valve of a secondary room (like a bedroom) to a temperature higher than the current temperature, nothing will happen. The valve may open but the thermostat won't request heat, so the room won't heat up. The reasoning behind this is cost saving, as it is difficult to request heat in a granular way out of the box (but we are going to do it 😉).

There is usually another mode, called Comfort (Or similar) that allows individual valves to request heat. You can heat a secondary room independently of the temperature of the room hosting the thermostat. This is the mode my system is in.

A climate entity is simply a representation of something that heats or cools (or both). It has a current temperature, a target temperature, and a mode. My climate entities are "pure heating" entities, they have only one mode, heating. If the target temperature is above the current one, it heats, else it is idle. It does not get simpler than that.

Presence

I also have presence sensors in every room. Mine are Everything Presence One. They are awesome.

A presence sensor is simply a sensor that detects presence (not movement!). These ones use a technology called mmWave sensing. They detect movements as small as a fraction of a millimeter, such as the chest movements from a beating heart, or breathing.

A simple boolean value that is either on when presence is detected, or off otherwise

Openings

I also have contact sensors on all my windows and doors. Mine are Zigbee Aqara sensors. I bought a dozen of them second-hand. These things are unkillable, I just changed the battery when I received them.

A simple boolean value that is either on when the "support' (door or window) is open or off otherwise.

This is all the hardware I use for my heating system.

The plan

In this blog post, I'll focus on a single room, not because I am lazy or want to hide complexity, but simply because it's all you need to know to understand the whole system. What I did in a room, I repeated it in every other room.

So I'll focus on my office, it's a pretty generic room in my home. It has a window with a contact sensor, a presence sensor, and a radiator. That's about it.

Let's start by looking at the bigger picture, and break it down into pieces.

I want modes, driven by a few inputs such as the state of my window or the presence in my office. Modes will drive the target temperature. The target temperature, and also the manual override, will drive the radiator.

• Inputs drive modes
• Modes drive the target temperature
• The target temperature (And the overdrive) drives the actual radiator

The modes

We need to start somewhere, let's start with the modes. They seem to be the simplest to grasp when starting from a blank page.

I want 3 modes in this specific room.

• Present when I am present
• Absent when I am not
• Vent when the windows are open

The target temperatures

I researched online the local heating recommendations and found that for a "living space", such as a living room or an office, the recommended target temperature when the room is used is 19°C. When the room is not used, it is 16°C.

Then, most heating specialists recommend setting a minimum temperature of 7°C if the windows are open to prevent pipes from bursting if something really bad happens and you need to leave your house unattended for a long time with the windows open in cold winter (This is called Frost Protection or Frost Guard)

The inputs

I do not want to change modes manually, so I need to find the triggers and conditions that will drive my modes.

We already talked about most of it, now let's clarify the details.

If the windows are open, whether I am present or not in the room, I want the mode to be set to Vent. To avoid constantly changing the modes, and also because a heating system has an inherent inertia, let's add a small minimum duration and say that the mode should be set to Vent if the windows are open for more than 5 minutes.
5 minutes could seem a bit random, but I usually vent my office during breaks. (I have an Air Quality sensor in every room that shows it's enough in my case)

Then if the windows are closed, I want the mode to be set to Present if presence is detected, else to Absent.  Let's also solve all the small nuances here. Presence detection can be finicky sometimes, and detect presence when there is not (We call this a false positive) or not detect presence when there is (We call this a false negative). I also want to avoid setting a room to Present just because I went there to grab something, so let's also put a 5-minute minimum duration. I also live with pets that constantly trip presence detection, I cannot really do much here but I can at least optimize one common use case: If the home is empty, then I'll ignore the granular room presence sensors.

All in all, it looks like this:

The override

The override can look daunting. Is it another mode? Is it something else?

There are dozens of ways to implement an override, but I picked the simplest one (It has limitations that I am fine with because I rarely use this feature)

In Home Assistant, you can trigger an automation when something changes, or when something changes and stays "there"  for a duration (We used that for the contact sensor and presence states above).

I decided to use this for my override, to trigger something when the target temperature of my radiator changed for 1 hour.

This can happen for two reasons:

• One hour after a mode change (in this case, the target temperature should be coherent with what the current mode is dictating)
• One hour after a manual override (in this case, the target temperature should not be coherent with what the current mode is dictating)

So I decided to simply re-apply the target temperature of the mode when the target temperature of my radiator has changed for 1 hour. If no override exists, it will be coherent and nothing will change. If an override exists, it will be erased.

Alright, the planning is done.

To be honest, we know what we want to do, but this still looks daunting at first. Look at the whole picture!

The implementation

In this section, we are going to implement this, but we are going to break it down into smaller, simpler, more manageable parts.

Eventually, the implementation will be a succession of simple parts, and the complexity will only lie in the whole.

The modes

Let's start simple, we defined 3 modes, let's represent them. We will use a dropdown helper that will represent our heating modes.

As we are going to create a few of them in this post, let's do the first one together.
Helpers can be found under Settings > Devices and Services > Helpers. Or simply by clicking on that big button:

The creation process of a helper is straightforward. Here is me creating the heating office modes.

The target temperatures

Each mode has a target temperature attached to it, let's create three new helpers, one per mode that store that target temperature. This time, we will use a number helper. I won't show all the creation of the helpers, it's a matter of following what is on the screen 😉

This is what we have done so far. Nothing is automated, nothing is even linked. We just have a dropdown and 3 numbers

Let's tie the targets and the modes by creating, you guessed it, another number helper that will represent the overall office target temperature. And this time, let's automate it.

The automation is really simple.

We trigger on everything, a change of mode or a change of our 3 helpers holding the target temperature for each mode.

Then based on the mode, we set the value of the office target temperature based on the target temperature of the mode.

The YAML looks like this but don't get discouraged by it, it's simple to do via the UI

alias: Compute Office Target Temperature
triggers:
  - trigger: state
    entity_id:
      - input_select.office_heating_modes
      - input_number.office_target_temp_absent
      - input_number.office_target_temp_present
      - input_number.office_target_temp_vent
  - event: start
    trigger: homeassistant
actions:
  - choose:
      - conditions:
          - condition: state
            entity_id: input_select.office_heating_modes
            state: Present
        sequence:
          - action: input_number.set_value
            data:
              value: "{{states('input_number.office_target_temp_present')}}"
            target:
              entity_id: input_number.office_target_temp
      - conditions:
          - condition: state
            entity_id: input_select.office_heating_modes
            state: Absent
        sequence:
          - action: input_number.set_value
            data:
              value: "{{states('input_number.office_target_temp_absent')}}"
            target:
              entity_id: input_number.office_target_temp
      - conditions:
          - condition: state
            entity_id: input_select.office_heating_modes
            state: Vent
        sequence:
          - action: input_number.set_value
            data:
              value: "{{states('input_number.office_target_temp_vent')}}"
            target:
              entity_id: input_number.office_target_temp
mode: single

Here is the result:

Prettty cool! We built a brick, a small brick but that complexity is taken care of now. We will never have to deal with it ever again.

Let's move on.

The inputs

Input will only drive the modes. Modes are already driving the target temperature. This is the beauty of breaking down the problem into smaller parts. Once a part is taken care of, we do not deal with it again.

The automation for this part is also straightforward.

I trigger on every input, some with a duration

• The state of my home
• The presence in my office with a 5-minute duration
• The state of my window with a 5-minute duration

Then I select the mode based on the conditions we already defined in the planning (If the window is open, it's Vent, if both the home presence and the office presence are on, it's Present, otherwise, it is Absent)

Again everything can be done via the UI, but the YAML looks like this:

alias: Compute Office Heating Modes
triggers:
  - trigger: state
    entity_id:
      - input_select.home_modes
  - entity_id:
      - binary_sensor.office_window
    for:
      minutes: 5
    trigger: state
  - entity_id:
      - binary_sensor.office_presence
    for:
      hours: 0
      minutes: 5
    trigger: state
  - event: start
    trigger: homeassistant
actions:
  - choose:
      - conditions:
          - condition: state
            entity_id: binary_sensor.office_window
            for:
              minutes: 5
            state: "on"
        sequence:
          - action: input_select.select_option
            data:
              option: Vent
            target:
              entity_id:
                - input_select.office_heating_modes
      - conditions:
          - condition: state
            entity_id: binary_sensor.office_presence
            state: "on"
            for:
              minutes: 5
          - condition: state
            entity_id: input_select.home_modes
            state: Occupied
        sequence:
          - action: input_select.select_option
            data:
              option: Present
            target:
              entity_id: input_select.office_heating_modes
    default:
      - action: input_select.select_option
        data:
          option: Absent
        target:
          entity_id:
            - input_select.office_heating_modes
mode: single

We built more than half now! And we did not even touch the radiator yet. Here are a few screenshots of different cases.

Presence in the house, but not in the office, windows closed.
Mode: Absent
Target temperature: 19°C

Presence in the office, windows closed.
Mode: Present
Target temperature: 19°C

Presence in the office, windows open.
Mode: Vent
Target temperature: 7°C

Let's finally drive this radiator

The two automations we created are simple. The first one drives the mode based on a few inputs, and the second one drives the target temperature based on the mode.

The last one is also going to be simple, especially since we have all this architecture already in place. We are simply going to drive the radiator itself based on the target temperature.

I trigger on two things:

• An immediate change in our office target temperature helper.
• A change in the radiator target temperature for 1 hour (this is for the override)

Then, regardless of the trigger, I will just apply (or re-apply) the target temperature to the thermostat.

It looks like this:

alias: Drive Office Radiator
triggers:
  - entity_id:
      - input_number.office_target_temperature
    trigger: state
  - entity_id:
      - climate.office_radiator
    attribute: temperature
    for:
      hours: 1
    trigger: state
  - event: start
    trigger: homeassistant
actions:
  - action: climate.set_temperature
    data:
      temperature: "{{states('input_number.office_target_temperature')}}"
    target:
      entity_id: climate.office_radiator
mode: single

That's it?

Yes! 3 simple automations working as a small chain

• The input drives the mode
• The mode drives the target temperature
• The target temperature drives the radiator

The end.

This is my whole heating system.

The 3 automations you saw are duplicated for every room. Some rooms have fewer modes like my bathroom that has no window, and some rooms have different modes, again like my bathroom that has a Boost mode, driven by a humidity sensor.

In the end, it's just a bunch of helpers (26), and a bunch of automations (20) doing what we just did together.

• Computing modes
• Computing target temperatures
• Driving radiators

This post is long because I decided to focus on all the small details. But nothing is complicated because we planned well and broke down the problem into small manageable parts.

Nothing is complicated, yet the sum is beautiful and complex.

I hope you enjoyed this post and learned something 😍

My complete Home Assistant configuration is available here

JLo ✌🏻

Hello 👋🏻

It's Wednesday morning, a perfect time to sip your coffee while I talk about a topic dear to me. Sustainability.

More precisely Sustainability in hardware products.

10 months ago, two start-up founders went on stage and unveiled the Humane AI Pin.

A wearable AI device that was supposed to replace your smartphone and assist you in your daily lives.

The keynote was met with skepticism, the mood was a mix of "A pretty dark Black Mirror episode" x "Do they see themselves as the next Apple" x "OMG please I do not want to live in this future"

A few months after that the first units were shipped and, as everyone would have guessed, the reviews were bad.

MKBHD called it the worst product ever.

• Overheating product
• Bad battery life
• Constant hallucinations.

This happens when you build a product solely on LLMs. Hallucinations are part of the game, but it's not all bad when you can close the ChatGPT app and search online to verify results, it's problematic, and borderline dangerous when "you don't do apps, you do AI experiences"

I hate AI scams, but let's say that for the sake of this article, I do not care. If investors are willing to pump money into these products, it's their problem, not mine.

Now we meet the part of the timeline that is dear to me. The returns. The verge states that "between May and August, more AI Pins were returned than purchased". So how does Humane deal with these returns?

They do not.

I'll quote the Verge again:

"Once a Humane Pin is returned, the company has no way to refurbish it, sources with knowledge of the return process confirmed. The Pin becomes e-waste, and Humane doesn’t have the opportunity to reclaim the revenue by selling it again. The core issue is that there is a T-Mobile limitation that makes it impossible for Humane to reassign a Pin to a new user once it’s been assigned to someone".

The secondhand market for the AI Pin is impossible.

I want to make my point very clear:

It is inexcusable and unacceptable to use resources to build a bad product that cannot be repurposed or re-used after the first purchase.
Scam people all you want. Take their money, and sell them air, but you do not waste the earth's resources. Period.

Let me tell you another part of the same story of sustainability in hardware products.

I'm part of the team building a new voice assistant at Nabu Casa & Home Assistant. We're soon going to release our own hardware.

The hardware will be open, and the software running on the hardware will be (already is) open, guaranteeing a long and sustainable life for every unit we release in the world.

Nevertheless, we produced a bit of waste during the development process. We went through 3 main revisions of the board. This means that boards were shipped to us, we tested them, found improvements, and asked our manufacturing partner to implement these hardware changes.

These intermediary boards had a lifetime of about a week and became "end of life" pretty fast. All in all, I think about 30 of these boards exist, only shipped to employees for internal testing.

This week is the production of the batch of 1000 units. With the development rush behind us, we are now spending a bit of time to make sure these boards do not end as dead weight.

Just because deep inside my guts, I was not sleeping well knowing I was part of a team that produced 30 boards that were destined to rot in a drawer.

Am I writing this to tell you "Their way is bad, our way is good"?

Absolutely not.

I am writing this to tell you "Their way is unacceptable and inexcusable, and our way should be the baseline for every company building hardware"

In every hardware pitch, we should see the following:

How do we make a product that does X while making sure it will keep working when our business model collapses, our servers shut down and our company dies.

Humane is not an isolated case, Spotify made the same move with their first (and only) hardware product a few months ago, we wrote about it too

Congratulations Humane on your first hardware product launch, the world hopes it will be the last.

Be better.

Today I am going to explain to you how to build this:

Ok fine! I am going to explain to you how to build this:

A way to play music, on a wide variety of speakers in your home, by voice, coupled with a very powerful search engine. Something that does not only match a song name or an album name, but also more complex queries, as you saw in the two videos above.

This blog post will assume a few prerequisites if you wish to follow along:

1. You need to be using Home Assistant. (Get started here)
2. You need to have a voice assistant configured on Home Assistant. (Follow our guides here).
3. You need an OpenAi API Key (Note: It costs money ... But it is dirt cheap, less than 1$/month even with all my extensive testing)

Excluding the prerequisites above, there are two main "blocks" that we need to cover in order to build our powerful search engine:

• Music Assistant
• OpenAI GPT

Music Assistant

Music Assistant is the perfect music companion for all Home Assistant users. It allows you on the one hand to gather all your music in a single place, whether it is located on streaming services or stored locally. And on the other hand, it allows you to stream it to almost any speaker (or group of speakers) compatible with Home Assistant.

Music Assistant is still in beta, so the installation is currently not straightforward. But I am going to guide you nevertheless.

The Music Assistant server

The first brick you need to install is the Music Assistant Server. It's an add-on available on a custom repository. Fortunately, we are thinking about convenience when we manage such a distributed product so we have some helpers to guide you, even for complex tasks like this.

Click here to add the custom repository:

And then click here to install Music Assistant:

When the add-on is started, you'll be able to add your music under Settings > Providers

And you'll be able to configure the auto-discovered speakers under Settings > Players

Even without going further on this blog post, Music Assistant, as a standalone product, is a great way to play music coming from different sources in different players in your house. You can even create groups of speakers from different brands, which is unprecedented in a music app.

The Music Assistant Integration

Even if Music Assistant is cool as a standalone product, now we're going to sprinkle some automation magic on top of it. And the first step is to integrate it into Home Assistant.

A Music Assistant integration exists on the Community Store, you can install it by clicking here:

Once installed, you should be able to integrate the players you created on Music Assistant (Groups or not) into Home Assistant

The Music Assistant Services

Since the last version of the Music Assistant integration, Music Assistant provides some very interesting services with great potential. It is actually the release of these services that sparked the whole idea of the smart music search engine voice assistant.

To put it simply, the service mass.play_media allows you to play music by describing it like you would on Spotify or Tidal: With an artist name, an album name, or a track name.

Here is how you play a track on an album of an artist:

service: mass.play_media
data:
  media_id: Hells Bells
  media_type: track
  artist: AC/DC
  album: Back in Black
target:
  entity_id: media_player.music_assistant_bureau_sonos

Here is how you play a complete album

service: mass.play_media
data:
  media_id: Back in Black
  media_type: album
  artist: AC/DC
target:
  entity_id: media_player.music_assistant_bureau_sonos

And here is how you play a complete artist

service: mass.play_media
data:
  media_id: AC/DC
  media_type: artist
target:
  entity_id: media_player.music_assistant_bureau_sonos

And that concludes the first "building block". You can now play any music you want on any speaker you want in your house with just a track name or an artist name.

Let's now dive into the second block, which is the voice commands

Voice Commands, and OpenAI to the rescue

2023 is (or was depending on when you read this blog post) the Year of the Voice for Home Assistant.

We shipped some pretty cool things such as the ability to repurpose almost any object into a voice assistant.

Really anything ... 🙈

The great thing about our voice assistant product is that it is fully customizable.

• You can change the wake word it reacts to
• You can change the language that you speak
• You can change the voice used to reply
• You can even create your own sentences and how Home Assistant would react to these.

This last customization point is exactly what we are going to do for that project. We are going to create a custom sentence that catches a "playing intent", and sends it to Music Assistant using the service we saw in the above section (mass.play_media)

A custom "intent" is composed of 3 main parts:

• The input sentence that will trigger it
• The list of actions that need to be executed once triggered
• The response needed to be sent back to the voice assistant

In order to provide more flexibility in the input sentences, Home Assistant provides a way to describe "free text" called wildcard variables. For example: What's the weather like in {location}? and we are able to get the content of our wildcard variables in the actions and so use them.

At first, I tried to create my search intent(s) "the old-fashioned way" by trying to match every possible use case:

• A track by an unknown artist play {track}
• An artist play {artist}
• An album by an unknown artist play {album}
• A track by an artist play {track} by {artist}
• An album by an artist play the album {album) by {artist}
• A track in an album by an artist play {track} in album {album} by {artist}

However, I faced lots of issues with intent matching and it became quite big and difficult to maintain quite fast.

Before giving up, I decided to try a different approach. I tried to find a component that would do the "music part of the matching" for me. That way, I would only have to create a single intent in Home Assistant :  play {query}, then I would pass  {query} to that magical component and get in return a structured way representing what track, album, or artist it is so that I can use it with Music Assistant.

And I found exactly what I was looking for with OpenAI GPT.

Large Language Models (LLM) are super good at doing fuzzy tasks like transforming a line of text such as "Hells bells from AC/DC" into a structure model like

{
	"media_id": "Hells Bells",
	"media_type": "track",
	"artist": "AC/DC"
}

In case you are not familiar with LLM (even if this is not the place to explain in detail how they work, most notably because.. well I don't know), a LLM is an AI model that has been trained at guessing the next word after a certain block of text.

So if you give The mouse was eaten by the to an LLM, it will give you back cat.

Not very useful in itself, but as the input block of text can be pretty long, we usually use LLMs paired with the concept of pre-prompt.

A pre-prompt is a set of instructions you give to an LLM before giving your actual input. A simplified way of thinking about a pre-prompt is to see it as a block of text you add before your input. For example, if you want to create an AI assistant that translates English to French, you may create the very simple pre-prompt: You're a bot that helps me translate an english sentence into a french one. Here is the sentence:

Then the LLM does what it does best: Guessing the next word after a certain block of text, except this time, the block of text would look like this:

You're a bot that helps me translate an english sentence into a french one. Here is the sentence: LLM are pretty powerfull

And you get yourself an AI assistant that is pretty good at translating English into French.

(Note: Coming up with good prompts is now a skill in itself, a bit too trendy if you ask me, called prompt engineering, the art of creating good prompts)

Before showing you the prompt I used to translate things like The song used in the opening credit of the Narcos TV show into the correct structure data, let me show you how to integrate OpenAI LLM (called GPT, yes not ChatGPT, ChatGPT is the Chatbot product from OpenAI using their LLM GPT)  into Home Assistant

Click here to integrate OpenAi into your Home Assistant:

All you need now is to input your OpenAI API key and you will be able to configure your OpenAI integration:

As you can see the configuration is pretty simple

• A prompt
• A GPT version
• A few parameters that I will overlook because they are not really useful for generating structured data

For the GPT version, keep gpt-3.5-turbo or use gpt-4 if you have access to it.

And here is the famous prompt. Warning: It's long

You are an AI process that transforms a music search query into a structured JSON. 

Here is the structured JSON that I expect in response {"media_id":"name",  "media_type":"type", "artist":"name", "album":"name"}

"media_type" can be one of 3 different values: "track" if the search is about a specific track, "album" if the search is about an album, or "artist" if the search is about an artist.
media_type is mandatory

media_id is the most specific from track, album, and artist.
If the search is about a track: Then media_id is the track name.
If the search is about an album: Then media_id is the album name.
If the search is about an artist: Then media_id is the artist name.
media_id is mandatory.

If case it is needed, the fields "artist" and "album" can be used to further restrict the search. 
For example, if the input is "Hells Bells by ACDC", then the output should be  {"media_id":"Hells Bells",  "media_type":"track", "artist":"AC/DC"}
"artist" and "album" are optional.

There can be 4 types of answers: 
Just an artist like that {"media_id": "artist name", "media_type":"artist"}.
An album by an artist like that {"media_id": "album name", "media_type":"album", "artist": "artist name"}.
A track by an artist like that {"media_id":"track name", "media_type":"track", "artist": "artist name"}.
Just a track if the artist is not known like that {"media_id":"track name", "media_type":"track"}.

You must reply with only the JSON model, nothing before nor after because your response will be processed by a search component of a media listening service. 

Note that the input query can be in French or English. 

Here are a few examples of input with the expected output:
"Hells Bells by ACDC" > {"media_id":"Hells Bells",  "media_type":"track", "artist":"AC/DC"}. 
"La discographie de Pink Floyd" >> {"media_id": "Pink Floyd", "media_type":"artist"}. 
"The artist that composed the soundtrack of Inception" >> {"media_id": "Hans Zimmer", "media_type":"artist"}.

Once the OpenAI integration is configured on Home Assistant, let's take a small detour to test what we just created.

In the developer tools, you can test the service called conversation.process. Just click here to test it:

Select your OpenAi integration and write some input text. Click on Call service and you should see the power of LLMs ☺️

BTW, A simpler way to test this, but completely optional is to create a separate voice assistant using this conversation agent.

Go to Settings > Voice Assistants by clicking here:

Click on Add Assistant and use your openAi integration as a Conversation Agent.

Nothing else matters on this screen as we will only use this voice assistant to test the prompt.  

You can now converse with this voice assistant to test your prompt

Putting everything together

Because we clarified all the building blocks needed, putting everything together is actually very simple now.

We are going to create an automation, that matches a certain sentence, passes the query to OpenAI, and then passes the OpenAI response to Music Assistant.

And the heavy lifting has been done for you, you can just use this blueprint:

Conclusion

I hope you learned something today. Contact me if you use the blueprint and you like it!

AI is a touchy topic, very trendy, I feel everyone is putting AI everywhere without a concrete reason. I enjoy that particular personal project because it shows AI solving an actual problem I faced.

Peace!
JLo

VR meetings? Do they work? Is it a gimmick? (Also, where are my legs?)

At Nabu Casa, all meetings (except for 1 to 1) are conducted in VR.
I've been in the company for a bit more than a month, so I decided to reflect on this unusual practice.

What works well?

VR meetings have had the sharpest focus I ever experienced. No side discussion, no phone checking. Meetings tend to be shorter, and straight to the point. This is a good thing in this day and age where companies tend to suffer from the too-many-meetings-not-enough-outcomes syndrome

I also noticed that we tend to cut each other less compared to a regular Zoom-style meeting.

I cannot really put my finger on the reasons, but the mix of spatial awareness and body language cues is clearly helping.

You see people facing you before they talk, you see who's looking at the shared screen, who's quickly searching for something on his/her computer.

Sound is spatialized so you have no issue understanding who's talking and where he/she is located. This is a definite improvement if you compare it to the flat 2D wall of sound coming out of a regular Zoom-style meeting.

You're in a room. It just happens that the room is virtual.

What does not work well?

Well for a start typing is harder, but it's a good opportunity to perfect your touch typing 😊

The biggest problem is that VR meetings work well until they don't.

The software used to conduct these meetings (Meta Horizon Workrooms) cannot be considered stable as of today. Connecting to a room is long and tedious, sometimes people get stuck trying to join or drop off unexpectedly.

The meeting size is limited to 16 to reduce lag. Past this threshold, later joiners are able to join a "zoom-style" version of the VR meeting.

They see the VR room, and people in the VR room see their faces on a floating screen. Just like a regular hybrid setup. This negates, in my own opinion, the whole point of VR meetings

Is it for everyone?

Absolutely not.

But this is something that I believe is worth exploring if you fit these two requirements:

• Small teams (less than 20 people)
• Full remote

Beginning of September, I started a series on Twitter and Mastodon called Home Assistant Hot Tip of the day.

I'll still post on Twitter and Mastodon, but this post act as a repository of all past tips.

I'll try to keep it as up-to-date as possible.

Last updated: 2023-09-11

Local Assist

Our voice assistant can be set up completely locally if you have enough CPU to perform Speech-to-text and Text-to-speech.

Here is a video comparing the speed of Assist using Home Assistant Cloud and running it locally.

Using Assist with Home Assistant Cloud is a one-click setup

(Actually, we set it up for you, so it's a zero-click setup)

You're also supporting the development of Home Assistant by using it.

Learn more here

Nabu Casa

Nabu Casa

Using Assist locally requires you to run Piper and Whisper locally

• https://github.com/home-assistant/addons/tree/master/piper
• https://github.com/home-assistant/addons/tree/master/whisper

The demo you saw above is NOT performed on a Raspberry Pi, it is performed on a powerful NUC i5 with a pretty heavy model for both TTS and STT.

Remote Backups

BACK. UP. YOUR. DATA

Since a few versions, Home Assistant supports network storage.
If you have a NAS, setting up a daily backup takes less than 2 minutes.

Seriously: Watch

Supercharged mushroom person card

Reflecting on yesterday's post about 🍄 Mushroom by @piitaya, I'd like to share my favorite card in my setup: The super-charged person card

It's subtle but this card packs lots of details that I absolutely love.

Can you spot them?

Here is what the card supports

Standard features:

• Show when a person is home
• Show when a person is in a zone

Added features:

• Gendered adjectives (Présent / Présente)
• Show where the person is if he/she is away (City, or City + Country if abroad)

This card is a template 🍄 mushroom card, mixing data coming from two different sources

• The person entity
• The Geocoded Location sensor coming from our companion app

You'll need the app to make this card work:

Home Assistant Companion Docs | Home Assistant Companion Docs

Welcome to the Home Assistant App docs

Companion Apps

You can find the card here:

Supercharged Mushroom Person card

Supercharged Mushroom Person card. GitHub Gist: instantly share code, notes, and snippets.

Gist262588213843476

Tile card and its features

Everyone loves 🍄 mushroom cards by @piitaya.
But do you know the native Tile card allows you to create a similar look and feel?

Here are some of my dashboards. 90% is native. I only use Mushroom for titles and subtitles.

The tile card and its features are also built by @piitaya

Turning off and on many automations at once

Most of the time, one "functionality" is implemented in many automations.
(For example, my "Smart cleaning" functionality is split into 12 automations)

Create an input_boolean helper and add it as a condition to every automation.

Result: A single button that controls the complete functionality.

Universal Media Player

So you have your TV as a media player, then Cast, then your speakers, then maybe Plex,  Android TV remote

And you wonder how to have a nice media center experience in Home Assistant

The Universal Media Player integration
https://home-assistant.io/integrations/universal/

This integration allows you to create a main media player by picking what works best in all your child media centers.

You can override the turn-on action, the volume actions, the state, etc

Here is mine for inspiration

home-assistant-config/packages/media_center/media_player_universal_media_center.yaml at master · jlpouffier/home-assistant-config

Open source configuration of my connected apartment - jlpouffier/home-assistant-config

GitHubjlpouffier

MacOS Companion app

Working on Mac? Did you know we have a native macOS App?

It exposes lots of sensors coming directly from your machine to your Home Assistant.

One of them is a boolean "Camera in use", I use it when I am in meetings.

The app is available on the AppStore

‎Home Assistant

‎Control and monitor your home from anywhere in the world. Home Assistant Companion lets you control all your devices and provides advanced location and notification engines to allow for complex automations. Home Assistant is an open-source home automation platform that focuses on local control and…

App StoreNabu Casa, Inc

Testing an automation by faking state change

So, you built an automation but can't test it in the real world?

The developer tools can help you simulate literally everything on Home Assistant.

Look how I can change the outside temperature without waiting to fix global warming.

But be careful, It's a double-edged sword - use it with caution. Make sure you put back real values once you are done testing.

Favorite colors

Did you know that lights have favorite colors?
Long press on them to edit them and add/remove some!

Absolute vs relative time display

In the new more-info screen (Available for Lights, Covers, Switches, Alarms, Fans, Sirens and Locks for now) you can change the way the last state change is displayed by clicking on it.

Aliases

You can add aliases to entities and areas. Aliases are alternate names that you can use when using Assist, our private voice assistant.

Note: Aliases also work with Google Assistant, but not with Alexa

Areas

Areas represent rooms in your home.
Until this year they have been used lightly in the product, but now they are a core part of Assist, our voice assistant.

Look how a good area setup can unlock great assist commands.

Note: Here I am writing the commands for the sake of simplicity but the commands are meant to be spoken

Dynamic scenes

You can capture the state of your devices in order to restore them later with 'scene.create'

Watch how the light state is restored in this video.

Script available here:

Home Assistant Hot Tip: Dynamic Scene

Home Assistant Hot Tip: Dynamic Scene. GitHub Gist: instantly share code, notes, and snippets.

Gist262588213843476

Scenes created with 'scene.create' do not survive a restart.

Note: Scenes created with 'scene.create' do not survive a restart.

Copy, Paste and Cut on dashboards

Similarly to yesterday's tip, you can COPY, CUT and PASTE cards within a view, across views, and across dashboards.

Here I recreate a dummy dashboard with only COPY, CUT and PASTE

Super useful when reshuffling views!

Copy, Paste and Cut on automations

You can COPY, CUT and PASTE blocs when creating automations.

It allows you to tweak what you are building with minimal effort.

Here I change the way conditions are checked and actions are run in a few seconds.

Wildcards

Wildcards allow you to match lazily part of a sentence such as "Add {item} to my shopping list"

Let's play a game:
What does this automation do?
(Think carefully)

Well, it chains 2 commands, right?

I can say "{Turn on the living room light} and {close the shades}"

Correct.
But this is not all.

Have a look

Since wildcards are lazily matched, the simple automation above is recursively called.

When I say "1 and 2 and 3 and 4", it is matched as such: "{1} and {2 and 3 and 4}"

And processing "2 and 3 and 4" calls the same automation and matches "{2} and {3 and 4}"

And so on.

Caveats (aka. Why this is just an experiment and you should think twice before adding it on your side):

• The structure is so simple "{1} and {2}" that this automation will be triggered when you don't want to.
  Like "{Add peanut} and {jam to my shopping list}"
• You won't get feedback if some commands are erroneous:
  "{Turn on the living room lights} and {make me a coffee}" will just ... "work"
  (But you won't get your coffee)

Still a cool experiment to learn wildcards

expand()

expand() is an advanced templating feature that lets you expand specific parts of your state machine.

This small sensor gives me the number of pending updates and their names.

For the state of the sensor, this is what the template does:

• It expands all the entities in the update domain
• It filters the ones that have a state equal to 'on' (update available)
• It lists them
• And counts them

The result is the number of pending updates (4)

For the attribute "entities",  this is what the template does

• It expands all the entities in the update domain
• It only keeps the attribute "friendly_name" for each of them
• It lists them
• And sort them

The result is a list of available updates

[  
  - Vacuum Update  
  - ..
]

A very simple automation triggered by this sensor, and you can be notified as soon as updates are available across your system.

Full sensor available here

Home Assistant Hot Tip of the Day: Available Updates

Home Assistant Hot Tip of the Day: Available Updates - available_updates.yaml

Gist262588213843476

Sentence trigger

You can extend what Assist understand by creating really simple automations.

Here is one triggered by the custom sentence "Raise the desk".

Home Assistant Hot Tip of the Day: Sentence Trigger

Home Assistant Hot Tip of the Day: Sentence Trigger - automation.yaml

Gist262588213843476

Automation editor

The automation editor packs a lot of features that help you during an automation creation.

You can:

• See triggers fired
• See the trigger data
• Test conditions
• Run actions

without even saving the automation.

Subviews

A subview is a view that does not appear in the dashboard top bar.

In this simple example, I use a subview per room, and navigate using Tiles.

The navigation card is available here:

tile_navigation_card.yaml

GitHub Gist: instantly share code, notes, and snippets.

Gist262588213843476

Coloring cards

Most cards use the primary color.
The Tile card can use the accent color.
Some entities like battery sensors compute color based on their state.

You can change the primary/accent colors to make Home Assistant your own.

How to use logbook data

The logbook holds valuable information, often overlooked.
In this example I dig up why a toggle was triggered and find out:
- The automation
- The trigger
- The conditions
- The user initially responsible

JL triggered the "Trigger toggle"
 and because the sun was above the horizon
  the automation "My Automation" was processed
   and turned on the "Result toggle"

Display precision

Change the display precision of your numerical sensors directly in the UI.

Note: This does not change the value of the sensor, just the way it is displayed.

Device class of binary sensors

Edit the device class of your binary sensors directly on the UI to change the way they are displayed (Icon + State labels)

Trigger IDs

Combine "Trigger IDs" and the "choose" action to group simple automations by little functional packages.

For example, this is a single automation that toggles a light based on the sun's position.

Decluttering your sidebar

You can declutter your sidebar and organize it by long-pressing on "Home Assistant".

I created a navigation card for everything "technical" so that it's not in my way every day.

The card is here:

Home Assistant Hot Tip of the Day: A Navigation Card to declutter your side bar

Home Assistant Hot Tip of the Day: A Navigation Card to declutter your side bar - card.yaml

Gist262588213843476

Keeping automation instant

Automations are not meant to be running forever.
They reset after a restart.
If you need to wait hours to perform an action, use an input_datetime and a second automation triggered by it.

These 2 automations are instant

Note: From a performance perspective, there is nothing wrong with having automation running for a long time.
You just increase the risk of having a restart in a middle of an automation.

Running a script vs turning on a script

RUNNING a script blocks the subsequent actions until the script is over.

TURNING ON a script is an immediate action that does not wait for the script response to continue to the next actions.

You can find the scripts used in the video here:

Home Assistant Hot Tip of the Day: Run vs Turn on Script

Home Assistant Hot Tip of the Day: Run vs Turn on Script - script.yaml

Gist262588213843476

Reusable logic on a template sensor

If you keep creating the same complex trigger/condition: Simplify your automation by creating a template sensor.
So that the logic is only in one place.

Here is my "Home Occupancy" sensor for example:

Home Assistant Hot Tip of the Day: Home Occupancy Sensor

Home Assistant Hot Tip of the Day: Home Occupancy Sensor - configuration.yaml

Gist262588213843476

Trigger Data

Triggers convey a lot of data, and you can see the data while building an automation!
Just fire the trigger and click on the "Triggered" banner.

Here is an example with the new wildcard trigger available since the 2023.8 release.

State of zones

The state of a zone represents the number of persons present in it.

You can very easily create triggers that will fire, or conditions that will match, when:

• Your home is empty
• Your home is occupied
• Your home is full

I created a small gist that contains them all:

Home Assistant Hot Tip of the day: home occupancy

Home Assistant Hot Tip of the day: home occupancy - conditions.yaml

Gist262588213843476

I have been working in Product for 7 years now.
I don't consider myself skilled as I believe I will never stop learning.

However, if there is one type of individual that seems to enjoy how I work, how I approach my job, and how I interact with them, it's engineers.
I decided to reflect, both personally and with some fellow engineer colleagues, and try to understand the reasons.

I hope that this article will give some leads to fellow product managers about how to work well with engineers.

Here are the key messages of this article:

• 💪 Do everything you can to empower your engineers so they own problems and not only solutions.
• 💡 Be curious and learn their language.
• ⚛️ Shield your team from the outside noise.
• 👩‍💻 Know your product, even its dark side.
• 📣 Align by communicating.

💪 Empowerment

The first and most important lead I would like to give to fellow product managers would be to empower your engineers as much as you can.

Non empowered engineers own solutions and have little interest in the "whys" that are behind these solutions (The users & customers, the problem to be solved, etc).
Empowered engineers own a problem. They leverage technology and context to figure out the best solution.

Non-empowered engineers are mercenaries.
Empowered engineers are missionaries.

Teams of missionaries are engaged, motivated, have a deep understanding of the business context, and tangible empathy for the customer.
Teams of mercenaries feel no real sense of empowerment or accountability, no passion for the problem to be solved, and little real connection with the actual users and customers.

Missionaries vs. Mercenaries

Marty Cagan considers empowering engineers is The Most Important Thing

Extracted from the Spotify Engineering Culture

Your goal as a product manager is to make sure everyone in your team gets why they work, and why your company believes in what your team is pursuing.

They need to understand the company's vision, and how your team's vision ties to it.
They need to understand the company objectives, and how your team is contributing to them.
They need to know their users, their wishes & pains, through accessible user feedback.

Empowering engineers is far from easy.
If not done right, it can lead to a lot of noise & overhead, and would be counter-productive.
It's a delicate balance.

My goal is to make sure the team is a great understanding of how we take decisions about what problem to focus on while maximizing the time the team has to find and build the best solutions.

Some tips on how I keep my engineers empowered:

• I take bottom-up inputs to revise the company product vision from each team member as part of a recurring event called the Rolling Strategy Process happening every 3 months.
• We shape the team product vision together as a team.
• I try to make sure that our contribution to the company objectives can be easily understood and tracked via accessible dashboards.
• I make sure user feedback is accessible by everyone in the team. I spend some time reading it weekly, and share a digest with my team.
• Once we know which problem to solve, we always ideate together in order to find potential solutions.
• When I plan to do some user interviews, I usually invite some of my engineers to one of them.
• If I need to talk to a third-party partner (for example we are actively looking for our next payment partner), I either involve some of my engineers or share updates regularly with them if I consider the session will be too high level.

💡 Curiosity

I believe that you need to be curious and learn what software development really means.

Admittedly, this may be a bit simpler for me: I have a master of engineering, I have a hacker mindset, and try to cultivate it with side projects every time I get a chance.

I cannot give you the scope of what you need to understand, as it vastly depends on how your company operates, and your affinity with learning technical topics.

Try to learn at least the following terms and concepts

• A front end
• A back end
• An API
• A data model
• A persistency layer
• A pull request
• A repository
• A deployment
• A rollback (or fallback)

I believe these will always be useful regardless of where you work.

Try also to learn

• The review & approval process (How engineers are making sure that issues are surfaced and fixed before reaching your customers)
• The deployment process (How a piece of software code transitions from done to available to your customers)
• The programming languages used by your engineers.
• The high-level architecture of your product

🤔 But ... how?
Start somewhere, book some slot with your engineers and ask them to explain something you don't know.I try to do a ☕️ Tech coffee every week to keep myself up to date on technical concepts.

Build something! There are so many resources online, it would be a pity not to use them.
It can be as simple as a slack bot if your company uses slack.

🤨 But ... why?
There are so many advantages to speaking the same language as your engineers.

Being able to grasp the challenges faced by your team, you'll be able to communicate them much more efficiently to your stakeholders.

Let me give you a real example.
Last week one of my front-end engineers told me "We should migrate one of our applications to NextJS".
I had no idea what it was nor why it was needed. I sat down with him and asked him to explain.

During our next planning event, this is how I will pitch it:

Our checkout application contains 3 pages : a delivery section, a payment section, and a success screen.
Today most of the code needed to run the 3 pages is loaded when our users reach the first page.
It increases the response time on a very critical flow of our product.
With NextJS, we will automatically load only the right code at the right time, decreasing the response time and optimising the overall user experience of our checkout.
On top of that, migrating to NextJS will reduce the number of dependencies that our front-end engineers have to tediously handle manually.

Did I totally understand this concept? Of course not.
Do I believe that the above pitch will be more convincing than: "We need to migrate to NextJS because my engineers told me so and I trust them 🤷‍♂️ " ? Yes. 100% yes.

⚛️ Entropy

Being able to grasp technical concepts will also help you to shield your team from the noise.

I'll quote Lenny Rachitsky

It’s your job to shield your teams from stupid shit. Like time-sucking questions, unnecessary drama, and the whims of execs. People outside your team have no idea how much impact their ad hoc asks and “quick” questions have on the team. It’s your job to help them see this, and to protect your team from them. Help your makers (e.g. engineers, designers, etc.) stay focused and in flow. Unfurl your shit umbrella.

See twitter thread

And I believe that the best way to shield your team from these quick questions is to be able to answer them yourself.

Then, consider the current iteration (sprint, cycle, whatever its name) unbreakable.

If your company has a good understanding and implementation of agile, you should rarely learn things that are going to jeopardize what your team is doing right now (ie, in the current iteration).

🤔 Why?
Because agile teams either build to learn if they are on a discovery phase, or build safe bets that are already validated if they are on a delivery phase.
Plus these safe bets are very small: the size of the iteration (usually short).

If a new piece of information makes your current goals irrelevant then:

• Either you are building something that was not validated in a discovery phase
• Either your iteration is so long that context changed

Even bugs are usually not interrupting our iterations...
Bugs are not more important than everything else by default.
If a bug is extremely severe (a crisis, an outage), then we drop everything and fix it. No question asked.
Otherwise, it waits until the next iteration (That is very short)

At Ricardo, we plan work in 6 weeks cycles. (Each cycle is composed of 3 sprints of 2 weeks)
We now reached a point where bugs are planned during each cycle, like everything else.

It's aligned with how Basecamp deals with bugs

There is nothing special about bugs that makes them automatically more important than everything else. The mere fact that something is a bug does not give us an excuse to interrupt ourselves or other people. All software has bugs. The question is: how severe are they? If we’re in a real crisis—data is being lost, the app is grinding to a halt, or a huge swath of customers are seeing the wrong thing—then we’ll drop everything to fix it. But crises are rare. The vast majority of bugs can wait six weeks or longer, and many don’t even need to be fixed. If we tried to eliminate every bug, we’d never be done. You can’t ship anything new if you have to fix the whole world first.

Shape-up

👩‍💻 Knowledge

This next statement is going to blow your mind :
As a product manager, you need to know your product 🤯

Pretty self-explanatory...
Or is it ?! (VSAUCE vibes)

It's one thing to know your product.

It's another thing to know

• Your product
• Its history
• Its bugs
• Its funky business rules
• Its quirks
• Its edge cases
• Why were certain decisions taken a few years ago
• What was already tested
• What failed
• etc.

A product is like an onion, and your users only see the outer layer.
A product manager should know the whole onion.

A good product manager should be able to break his own product by pressing exactly where it hurts, and then explain to everyone why the team never worked on this specific edge case.

This is super useful for your engineers. You can point them towards potential pitfalls, dark edge cases that may cause a problem a few iterations down the road, and so on.

A small tip:
I keep a list of onboarding challenges that I use every time a newcomer is joining my team.
It consists of a list of tasks (or jobs) to be done on our product, as a user.
Each job is more complex than the previous one and builds on top of the learnings of the previous jobs.

It's a very fun way to learn your product and its intricacies as an engineer.

Example of an "onboarding challenge"

📣 Communication

As a product manager, you also own the newspaper that talks about your product, and you need to keep it alive.

Document and communicate every major decision the team is taking, so that you don't have the repeat why you are not working on that-pet-project-your-CTO-always-talks-about.
🎯 It's a great way to shield your team even more from the noise.

Share your team's success and its learnings.
Share what your users think about your new features.
Share the impact you are making, and why it is instrumental to the company's success.
🎯 It's a fantastic way to remind engineers why they work and empower them.

When it comes to communication internal to your team :

Document how features are built (Usually in a document called the product requirements document [PRD])

• The assumptions
• The tests you made, and their results
• The business rules
• The design choices
• The wording choices
• The edge cases that are considered out of scope
• What you decided to track, and why.

🎯 This will be extremely useful to the team for future increments (Nobody will remember everything after a few iterations)

Over my 7 years of experience in Product, I have managed to be predictable only for the last 8 months. This article shed some light on how.

What is predictability?

As in every company, my team and I are asked to be predictable.

At a certain point in time, we have to say what we plan to do over a certain period of time.
Once the time period is over, we have to review if we did what we said.

👆 This is the definition of predictability.

🙋 Why do we need to be predictable in the first place?

For many different reasons!

It's very difficult for a company to believe in an idea if you cannot put a price tag next to it.

An unpredictable team will get stuck on dependencies with others.
The execution will be sub-optimal, for the team, but also for everyone that will be affected by the dependencies.

An unpredictable team may be working on the wrong thing.
A "Quick win" that a team prioritized now could very easily become a "Very long fail" if the team failed to see some UX or technical challenges.

An unpredictable team may "sprint" at the end of a period to finish things over.
It may neglect quality to "check" some arbitrary boxes.
I used the word "sprint" on purpose.
People should never sprint. Stories, tasks, things (call it however you want) should sprint.

Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
- Agile Principle #8

🙋 Can we become 100% predictable?

I don't think so. Estimation is an art.

The only way to estimate some work with 100% accuracy & 100% confidence is to do it.

This means that any estimation methods lies between these two (useless) extremes:

• Estimation cost 0 & accuracy 0% (For example: "give me your task I'll size it randomly")
• Estimation cost = implementation cost & accuracy 100% ("give me your task, I'll do it and tell you afterward how much it took me")

Any other method will introduce risks and bias.
It's a balance between the effort it will take to estimate and the accuracy of the estimation.

Predictability at Ricardo

💡 Note: At Ricardo, we like to revise iteratively our processes in order to continuously improve the way we work, so this article is not the definitive guide of how to be predictable. It is where we are, as a company, on our predictability journey.

⭐️ We believe that a common lightweight framework is required to align at the company level.
Similarly to many other companies, we do not believe in ready-to-use frameworks built by others that have to be adapted to our way of working (SAFe among others).
We believe that following the agile principles and creating something of our own is far more efficient.

At the company level, we plan work in chunks of 6 weeks that we call a cycle.
The 6-week planning chunk is becoming the norm for more and more companies, I will quote Basecamp:

We wanted a cycle that would be long enough to finish a whole project, start to end. At the same time, cycles need to be short enough to see the end from the beginning. People need to feel the deadline looming in order to make trade-offs. If the deadline is too distant and abstract at the start, teams will naturally wander and use time inefficiently until the deadline starts to get closer and feel real.

After years of experimentation we arrived at six weeks. Six weeks is long enough to finish something meaningful and still short enough to see the end from the beginning.
- Shape-Up

This article is going to be mainly focused on how we plan a cycle as a company... but first, let's quickly review how we operate inside a cycle :

⭐️ We believe that teams should have the freedom to adapt their process:Each team is free to organize the work the way they want within a cycle.

This is self-management at its finest.

Scrum Teams are [...] self-managing, meaning they internally decide who does what, when, and how.
- 💬 Scrum Guide

Some teams are doing 6 sprints of 1 week, others are doing 3 sprints of 2 weeks, others are using Kanban.
Each member of the company is invited to a single demo event, every week.
Each team chooses if they want to show something they shipped or learned, or if they pass their turn.
That's it.
It is as lightweight as it gets.

The Festival

In between two cycles, we have a 2-day event that we call a Festival ("We rock" was one of our internal slogans when we started the festivals and the name stayed 😊)

Our Festival main goal is to commit on the best possible plan to execute, as a company, for the next 6 weeks. It's an alignment exercise where, as a team, we build and share our plan to move our business forward.
- Dimitri Kandassamy - Head of Delivery

The main goal of the Festival is surfacing all the possible dependencies and connections between all the departments and align employees to pursue all together the main goal of the company, precisely, directly and delivering it with high quality standards.
- Mirko Brambilla - Engineering Manager and Agile Lead

A Festival is always composed of the same parts, in the same order

• ✨ Demo
• 🎤 Pitch
• 🍷 Speed Dating
• 🗺 Planning
• 🎯 Final Presentation

🎶 ACT 1: The show must go on

The ✨ Demo is built like a show.
Each team goes on stage and has 10 minutes to show the impact created over the last 6 weeks.

We show that the needle moved, or we show what we learned to make it move the next time. We are emphasizing on the outcome we reached, and of course the outputs we built (Don't fall in love with what you do, fall in love with why you are doing it)
The format is free.
Some teams are doing collaborative demos across different platforms, with some story-telling.
Some are playing with the audience.
Some teams are preparing after-movies.

✋ Personally, I am a big fan of presenting the problem by showing the user experience as it was before: Broken, boring, too long. Focusing a lot on the problems.
Then presenting what we did with the new experience, focusing a lot on the solutions we brought to the product.
Finally concluding by showing the impact of what we just presented: User feedback and data points.

🎶 ACT 2: I can show you the world

After the demo, each team is 🎤 Pitching an opportunity.
The pitch is the presentation of the wished scope and the expected impact that the team wants to deliver in the next cycle.
The pitch is prepared by all the members of the team (engineers, designers, product Managers) and presented by the product manager.
Once again: the format is free.
All that matters is that the team is able to convey :

• What outcome they want to reach ...
• ... thanks to what output.

✋ I like to make my pitches as if they were "trailers for future demos".
I present the problem with the current user experience, I present what I plan to build with anything that can make it interesting: early designs, interactive prototypes, storytelling:
Some PMs like to explain much more in detail the reason behind their team choices.

🎶 ACT 3: Is this the real life? Is this just fantasy?

Most of the time (if not always 😊) pitches are too idealistic.
We forgot some tasks or some duties, we assumed a department will be able to fully support us, etc, etc.
This is why the remaining part of the festival is used to "reality check" each pitch: This is the role of the 🍷 Speed dating.

With the speed dating, each team gets the opportunity to stress test their plans, receive feedback and understand different perspectives from stakeholders. It's also the time to understand our dependencies better

At Ricardo, each opportunity team meets the following stakeholders and tries to answer the following questions:

SRE team

• Did we take into account all the infrastructure aspects of what we plan to create?

Engineering heads

• Is technical debt handled?
• Are post-mortem actions from past incidents taken care of?
• Did we consider our engineers' well-being? (Personal projects, technical training, etc)

UX team

• Did we plan research efforts?
• Do we need UX writing?

Customer Care team

• Are the main customer pain points taken care of?
• Do we need to train customer care agents for big new features
• Is our help center up to date?
• Does our internal customer care administration tool need new functionalities?

Data Intelligence team

• Can we generate insights based on what we plan to build? (Do we know what to track, and how ?)
• Are we lacking insights, and do we need to plan big data analysis (Like cohort analysis)

Marketing team

• Do we have a go-to-market strategy, and do we need the marketing team to support us

Business Development team

• Did we take into account our key accounts?
• Do we need to talk or interact with our key accounts?

SEO team

• Can we use what we plan to build as an opportunity to promote our product?
• Are there SEO risks related to what we plan to build?

✋ Speed dating is exhausting.
I like to bring the whole team with me, and assign a note-taker for every session (10 minutes per session).
I received great feedback from some developers that are learning or discovering some aspects of our work in these sessions (the research efforts for much later, the marketing campaigns we are trying to create to advertise our new features).

🎶 ACT 4: By now you should've somehow realized what you gotta do

As you may have guessed, the opportunity teams usually finish the speed dating with a list of things they initially overlooked, a bunch of dependencies they did not think about, and a more accurate picture of the availability of each department that must support their opportunities.

Naturally, the next step is to revise the scope of the opportunity based on every learning of the speed dating sessions.
In other words: We 🗺 Plan
We take the initial (and idealist) opportunity pitch and all the outputs generated from the speed dating, and we create from these a realistic plan.

This is when we ruthlessly prioritize between opportunities, operational work, and requests so we build the best possible plan while keeping in mind the constraints of running our business

The plan is composed of the scope that we commit to deliver during the next cycle and the milestones we plan to hit.

This plan takes into consideration everything:

• Features we plan to develop
• Support from other departments
• Quality work: Bugs, Technical debt, Design and UX debt, Post Mortem actions, Technical improvement
• Research effort
• Holidays, Training, Personal projects
• etc

This plan is a commitment from the team.
✋ The more we prepare and refine what we bring to the festival, the more accurate our estimations are.
During this session, we try to answer these questions:

• Do we all have the same understanding of what we plan to deliver, and why?
• Did we plan all the dependencies that we knew or that we discovered during the speed dating?

And then we put a rough estimate on each user stories and place them on a timeline.
We try not to overthink the planning, as we will refine these tasks every week during the cycle anyway.
Finally, we decide what is not making the cut.

🎶 ACT 5: Snap back to reality

Finally, we close the festival with the 🎯 Final Team Presentations.
Each PM goes back on stage and presents their committed planning, focusing on the delta with their initial (and idealistic) pitch.

Everyone leaves the festival with a clear picture of what we are going to deliver, why and when, and with the certainty that most of the dependencies and other blockers will be handled

The Festival Preparation

During a cycle, the team dedicates some time to prepare what they want to pitch next.
During the 4th week of a cycle, the team meets the leadership team for a "cycle preparation", where they have the chance to "rehearse" their pitch.

This session is twofold:
💬 It is a discussion between the team and the leadership team.
🚦 It is a decision meeting: the pitch is either green-lit or some aspects need to be revised before the festival (For example: maybe the expected impact is not aligned with our company OKRs)

Conclusion

We just ended our 20th edition of the festival 🎉
We are still adapting, trying, practicing. Our festival is and will always be a living process

Practice isn't the thing you do once you're good. It's the thing you do that makes you good
- Malcolm Gladwell

I joined the company 11 cycles ago (1.5 years ago), it's amazing to see the result of our practice.
We are becoming more and more predictable and impactful.

1.5 years ago, for cycle #9, my team and I committed to delivering a proof of concept of a delivery service.
The plan was invalidated within the first week: We forgot to plan technical debt and our delivery provider was not ready to provide us with usable APIs.
We could have predicted it!
Last cycle (cycle #19), we completed all our main product goals (spread across iOS, android, and the web), technical goals, and quality goals.

We are not working faster, even if it feels much faster.
We just know where we are going now, we are predictable.

1.5 years ago we were entering a maze every new cycle, now we still enter a maze but with google maps and some nice drone shots to show us what danger lies ahead.
- Me, just now

This is what Jeremy Seitz said to all engineers when he was CTO at Ricardo.

When I asked Jeremy if I could quote him for this post he gave me a bit more insights 💡

Code is a cost, not an asset.
We should never be afraid to rewrite or delete code due to ego or sunk costs.
You’re a great engineer if you deliver results
The product is what has to be perfect, not the code.

First of all: I think it is amazing to hear these words from a CTO ❤️
This really speaks to the culture we have at Ricardo.
You should definitely check us out 💪

But here is my point of view: The product does not have to be perfect.
The product, just as the code, is an Output. Outputs are never complete

There will always be a way to add more features to a product, to make a user experience more appealing, or to make an API more robust.

Everything is a cost, the whole Output is expandable: The Product, the Code.
It all serves a higher purpose, The Outcome :

• The user pains you are trying to solve
• The benefits you are trying to bring to your users
• The value

This is why the 🎯 Outcome should always be the starting point for everything you do:
Don't fall in love with what you do (The Output)
Fall in love with why you are doing it (The Outcome)

If it means removing code, removing features, removing product ... Do it.

Everything you do today will be considered debt in the near future.
Not only code: The market evolves, your users evolve, standards evolve.
What is considered bleeding edge will become has-been one day.

Un-used features have a cost, but it's not money:
It is 📱 screen real estate, 🧐 mental load... and these are limited resources.

Outputs are never complete.
This is why instead of thinking in estimate: "How much time do we think this output (this feature) will be delivered ?"...
I like to think in appetite: "How much time are we willing to invest to reach this outcome? And what could we build in that time frame ?"

Read more on working with appetites instead of estimates here

I will quote:

Estimates start with a design and end with a number.
Appetites start with a number and end with a design.

Of course, trying to reach an outcome with an appetite of a week compared with trying to reach it with an appetite of a year will not lead to the same output... the same product...
One will be much more refined than the other

Thinking in relatively small appetites (6 weeks for Ricardo) allows you to stop and reflect frequently about where you are compared to your targeted Outcome... and decide if you have more appetite or not for it.

This is the most effective way to make sure you are always working on the most important thing and not spending time over-optimizing something that is already good enough for your users.

📖 Further reads :

Escaping the Build Trap - Melissa Perri

I'll quote one of the first sentences

Companies end up in the build trap when they misunderstand value.
Instead of associating value with the outcomes they want to create [...], they measure value by the number of things they produce

One of my 2020 New Year resolutions was "A month without social network".
The least I can say is that it was an enabler for me 💪

I spent way too much time in front of my screen endlessly scrolling for my next shot of dopamine.
So in March 2020 (after a 🍸 Dry January and a 🍗 Vegan February - Maybe the subject of another blog post 🤔), I went all-in:

I disconnected all my devices from:

• Facebook
• YouTube (If you think YouTube is not a social network.. good for you... Don't spend too much time.. YouTube is the final boss of Social networks for me)
• 9gag
• Reddit
• Instagram
• Twitter
• LinkedIn

and removed all apps from my phone.

The month went on ... like a breeze.
(Yes: it's actually easy to survive without social network, it's not like air or sleep ... Who would have thought 🤷‍♂️)
I honestly felt it was a loss of time.

It was only in April, when I was back on social networks, that I started to become way more aware of the enormous amount of time that I was losing scrolling endlessly 👀 ...

The research

So I did as any curious person would do... I researched:
Why are we addicted to social media?
What is happening inside my brain when I scroll Facebook?
What's in it for Instagram when I interact with content on their platform?

Obviously, these answers are well known ... Everybody knows it.
Yet I found it extremely interesting to do my own research.

A TL;DR:
Companies collect your behavioral data to sell them to other companies that are using them (The more common example is targeting ads).
The more you interact with such platforms, the more data they collect, and the more precise the targeting is.
Social networks use strong cognitive biases such as the Default choice, The Ikea Choice, the Esthetic reward, etc., etc. to trick your brain into asking for more content.

Do you remember the time when the web was paginated?
The designer of the "infinite scrolling" thinks that his creation (Although extremely effective in keeping you engaged) wastes around 200'000 human lifetimes every day

• Watch the wonderful video series "Dopamine" on Arte available in French, English, and German... It is an amazing eye-opener...
• Dig deeper with Netflix's /the social dilemma if you have more time.

The point is: that I became data-aware.
I started to research how the services I was using were using my data...
And I decided to see if I could find more "data-responsible" alternatives... or as a fallback, ways to reduce the usage of a specific platform.

The solutions

👍 Facebook / 📸 Instagram

Eventually, I ended up deleting my Facebook and Instagram accounts: No alternatives here.

🎥 Youtube

I did not manage to find a way to fully replace YouTube yet.
However, I found some pretty good tricks to better own my watch time.

1. De-activate Auto-Play
2. Replace your YouTube bookmark with https://www.youtube.com/feed/subscriptions that way you will go straight to the content YOU subscribed to, and not the content YouTube thinks will keep you engaged.

🔍 Searching the web

I replaced Google Search with DuckDuckGo.
For personal tips and learnings:

• Google search is miles away from any competitors in terms of search accuracy.
  (They have way more data, they understand much more precisely your search intents, they give better results, rinse, repeat, profit)
• The above point 👆 can discourage you, because when you venture into the unknown, you will focus more easily on things you don't like.
• ✅ Tips for new DuckDuckGo users: It is okay to give up and want to fall back to Google sometimes... DuckDuckGo has you covered. It's called bangs. Just prefix any search by "!g" and you will fall back to Google automatically. Just like that
• ✅ Using Qwant? prefix your search by "&g" for the same result. They call them qwicks

✉️ e-mails

I replaced Gmail with Hey
I am going to be honest with you... Hey is weird.
Hey is not "yet another mail client".
Hey is doing almost everything the opposite way than other mail clients... I love it 🔥.
It's pricy though .. 99$/Year
I would suggest you check the feature tour before committing to Hey...
I would understand that people dislike Hey, as it is so far away from anything we know about emails...

I tried others before:

• TutaNota
• ProntonMail

Both security-oriented mail providers... way cheaper too.

But as a PM, I got attracted by some of the features that Hey offered, and at the end of the day, I think it's worth every penny.

🌍 Browsing the Web

I replaced Chrome with Brave.
Brave is a Chrome-based browser.
This means you can use everything you know and love about Chrome (Extensions, shortcuts, etc, etc.).
It's available on all platforms (iOS, Android, Mac, Windows, name it)
Fewer barriers to migrate for you 🎉

Brave has a really well-thought built-in tracker and ad blocker, and it works amazingly well.

19 data points blocked after 2 minutes of watch time on YouTube...

I honestly don't see a single negative point with Brave... Give it a try now.
You will be surprised to see how many trackers Brave is blocking for you.

💬 Instant Messaging

I created a Telegram account and a Signal account a long time ago...
The biggest barrier to switching an instant messaging app is that you also need your friends to do it 😅.
But honestly, since the whole "Whatsapp - Facebook will share your private data" debacle, everyone started to talk about Signal...

I managed to migrate my 4 most active multi-chat groups on Signal...
I said to myself "It's a good first step" ...
Well, it turned out to be an amazing first step, It's been 2 months since I opened Whatsapp.

More and more people are trying out Signal...
Speak to your friends, I am pretty sure you are not that far from saying "bye-bye" to Whatsapp.

☁️ Cloud Storage, 🌅 Photo Storage

Like a lot of people, I got hooked by Google Photo.
Fast service, unlimited storage for free...

💡 Heads-up if you are not aware and if you are using Google Photo: Google Photo is changing its storage policy: Starting June 1, 2021, any new photos and videos you upload will take up storage space.

This one is, unfortunately, a bit more hardcore to replace 😓
I own a Synology NAS, and for a few months, I have been using their Moments service...

So I am now storing my photos locally in my own "Cloud".

Moments is available for both Android and iOS...
The web app is wonderfully designed (Strong inspirations from Google Photo)

The only negative point of this alternative is the price 🤷‍♂️ ...

• A NAS costs roughly 300$
• Add 300$ of Hard drives

🗺 DNS Routing

This one is much geekier than the others...
That's why it's the last one 😅.

For those not familiar (like me before starting this project), there are some servers acting as big "Address book of the internet": DNS Servers.

Every time you type an address on your browser (let's say www.google.com), it goes to a DNS server... and the DNS server replies:
Yep ! The closet way to go to www.google.com is to reach this random server 64.233.160.0
So you don't have to remember IP addresses by heart... (They change anyway so 🤷‍♂️ don't try)

Interesting to know...

• Almost all third-party ads on a website are coming from the same sources... The famous companies that are making a profit by targeting ads. (Like criteo)
• Almost all tracking points are collected to the same destination ... (Like Google Analytics)

When you load a webpage:
If this webpage is integrating a Criteo ad: a DNS query will be sent to resolve criteo domain.
If this web page is tracking your behavior... It will try to send data to Analytics, and the DNS will have to resolve it too.

Most of the time, DNS servers are owned by big companies (Cloudflare, Google, Your Local ISP ...)

Some projects are using this "Single point of resolution" as a powerful way to block Ads and Trackers:

• AdGuard Home (I am using that one)
• PiHole

In layman's terms (that's all I know anyway) :
It's a local DNS server.
For almost every resolution request, your DNS server is going to delegate the resolution to an upstream DNS server (So it's a lazy local DNS)
Your local DNS server has a list of every ad domain and tracking domain.
For those resolutions, it does not delegate anything: It just routes them to a back hole (Literally: 0.0.0.0)

It's like having Ad Block on your network.

Every connected device benefits from it

• Your TV
• Your connected lights
• Your friend phones
• Etc .. etc...

A safe bubble 💪

I was surprised to see the share of resolution blocked...

~15% of all my DNS resolutions are blocked by AdGuard Home.

That's right... 15% of internet resolutions are either for Ads or for Tracking 🤯

The most blocked domains for me are:

• Analytics related to my PhilipsHue lights
• Analytics related to my smart climate control
• Analytics related to my smart vacuum cleaner
• Analytics related to Netflix

Conclusion

I hope you learned something about what you can do to start owning your data.
Start small: Use Brave, Try DuckDuckGo. These are 2 really easy steps.