Why I’m stepping down as Head of Engineering

2025-07-26T05:00:00-05:00

Four years after founding the company, I’m stepping away from executive management at LocalStack. It was not an easy decision, but came after months of reflecting, and the honest realization that I was drifting away from the kind of impact that gives me energy. I’m now moving back into a cross-team IC-focused role, and it’s a good opportunity to tell this story, in the hopes it might help others in similar situations find the courage to make a change!

The road to now

Bootstrapping LocalStack

It’s April 2021, and we’re a couple of months away from incorporating. I reach out to some of the best people I’ve worked with in the past, and convince them to quit their well-paying and secure job and instead join a scrappy little startup with a small seed funding of $3M. To my initial surprise, almost everyone I reach out to is all-in. The energy this gives me is hard to explain, but it resolves all the doubts I had about letting my other ventures go to focus entirely on LocalStack.

LocalStack Founders at re:Invent in 2022 (fltr: Thomas, Gerta, Waldemar)

Together with this rag-tag group of six engineers and my two co-founders, I roll up my sleeves, and set out to do the prep work for our long growth journey ahead, transforming the LocalStack OSS project, Waldemar’s incredible creation, into a world-class product platform.

Almost all of those folks are still in the company by the way. Having grown to senior, staff, team lead, and engineering manager roles, they continue to be the bedrock of our engineering team, and I’m incredibly grateful to them.

The joy and cost of generalist leadership

Being a Lead Developer

I spend a lot of my time in the code base, finding bottlenecks for our growing team. While building new product features myself, I also start solving some higher-order problems. Like building a framework for generalizing the development of AWS service emulators, which has since transformed how we work at LocalStack. I also spearhead initiatives like dogfooding LocalStack, where we deploy and test our AWS-backed platform on LocalStack. This also marks the beginning of the LocalStack extension system, which allows us to emulate our payment backend Stripe directly in LocalStack. It is innovative and deeply technical work, and with our small team of highly skilled and driven engineers, the progress we make feels spectacular.

Being a Company Architect

With my co-founders focusing heavily on the business, in particular customer and investor relations, my natural focus is facing inwards, essentially greenfielding the company with this young and highly driven team. I can focus working on the things that drew me to found a company in the first place: to create an interesting place to work, where people show up because they can work on things they care about, with people they enjoy working with. So naturally I spend a lot of time thinking about culture and designing ways of remote work collaboration.

We lack executive-level or director-level people with deep industry experience, and being first time founders, most of what we do and how we do things comes from first principles and our intuitions. So I immerse myself in literature and learn how other companies do things. I learn about 3M’s 15% time, Valve’s flat org structure, Basecamp’s Shape Up, DoorDash’s “We Dash”, self-organizing projects like Kubernetes, and many other ideas, which inspire processes we design with the team: our Incubator program to foster bottom-up innovation, regular hackathons to try out crazy new things on company time, Mentors instead of Managers, Special Interest Groups, and a “We Support” support rotation where everyone (co-founders included) is put into the shoes of the customer, all of which shape the culture at LocalStack, and creates a place where people love to come to work.

All these ideas, cherry-picked and adapted from other successful and unique ventures, end up forming “The LocalStack Way”. Here’s a collage from that presentation that I should probably write a separate post about:

Everything everywhere all at once

As founders we tend to be everywhere at once, shaping systems and teams across the company. In this undefined role, I execute quickly with the team, lay out the technical vision for the core product, make process and hiring decisions across functions, and start building out other teams.

While my co-founders are building out other areas of the organization like HR, sales, and finance, I step in where there are gaps. We hadn’t set up a clear reporting structure at that point, but effectively I’m managing Engineering, DevRel and Support, scaling the teams, and experiment and build together with them. We don’t have a product team yet, so a lot of product work is driven by myself and the CTO.

Cycling between Engineering, Support, DevRel, Product, Leadership and general Founder activity takes a lot of mental energy. But being so plugged into everything makes designing transversal systems and being the glue between teams much easier. I constantly have the full context allowing me to give clear and coherent directions. Overall things are moving fast, they’re challenging in a good way, and people are genuinely excited to be here. It’s very gratifying.

Becoming specialized

With all our growing teams, it’s becoming more evident that we soon need people who have actual experience in scaling these org functions. We’re around 35 people at this point, and we start hiring a Head of Sales and a Director of Engineering.

LocalStack Team in January 2024

As the teams grow and the foundations are set, I find myself drifting away from the undefined “company architect” role I loved and thrived in. My scope progressively narrows to a Head of Engineering role, responsible primarily for scaling delivery, managing people, and keeping the machine running. I’m no longer interviewing every person who joins the company, but focus now primarily on engineering. More and more of my work happens through others, managing managers and team leads.

I’m also spending more time on foundational things in the engineering department, like designing a career and performance evaluation framework, or setting up OKRs for the next quarter. I like working on those things, but I notice that the work no longer translates naturally to other parts of the organization as it has previously when my role was less specialized.

Breaking points

Drifting from my passion

In 2024, I spend most of my August, September, and October either in 1:1s, candidate interviews, or planning and decision making meetings. I actually hit a low point in technical contributions, which I know I shouldn’t be doing in my role in the first place. Clearly this is not a problem with the role per-se, but with me being terrible at saying no to things. I care too much about everything, and my founder instincts keep pulling me into being everywhere at once, although it’s now completely incompatible with the reality of our, at this point, 70 person company.

With my calendar now being basically fully booked two weeks in advance, it’s becoming harder and harder to carve out what I now know as “maker time”. Whenever I do, I feel guilty for neglecting things I should be focusing on more. And whenever I lean fully into management, despite doing it well, I feel restless and somewhat disconnected from the work that had brought me here in the first place. Charity Majors calls this the engineer/manager pendulum, and some thrive in the swing between modes.

Having spoken to other founders and technical leaders, it’s what many of them end up learning: being good at management doesn’t mean it’s where you’ll do your best or happiest work. I realize that in becoming more specialized, I was also becoming less impactful in the way that matters to me the most.

Losing sight

Together with our expanded leadership team, we organize a management offsite. Two full days spent discussing our many challenges and growth pains, mapping out the next year, and preparing for the changes that Series-A growth will demand.

In earlier phases, moments like this absolutely filled me with energy. I could see with clarity what was needed, and I could see myself stepping into a role that was required of me with purpose and deliberation. But this time is different. Something had shifted: I realize I no longer see myself in the role that this next chapter requires, which had become one of managing and operating at a distance from the work I loved: shaping systems, teams, and products hands-on, all while providing vision and guidance to the teams. But with the way the leadership team is developing, and my two co-founders holding three executive roles: CEO, CTO, and COO, I realize that I’m stuck and my energy and values are pulling me in a different direction.

Being in the trenches again

It’s late October, and I’m called into our Vienna office to deal with yet another office malfunction: water dripping through the ceiling. Again. But it allows me to spend time with everyone like in the early days. I make a round through the office, ask everyone how they’re doing. Some conversations take a minute, others turn into spontaneous paring sessions. I work through an issue with them, and they end up with more clarity and determination than before. I leave the room full of quiet satisfaction, not because of status or authority, but because I was in it again. Present, useful, and technical. Something I realize I’ve been missing deeply over the past months. I didn’t even notice the water dripping onto my laptop.

The next day, I start writing down why I’m going to step away from executive management, and start preparing for the meeting with my co-founders to let them know.

Re-defining impact for myself

Disconnect to reconnect

After months of planning and handing over all of my responsibilities, I took a two-month leave. It felt strange at first, and of course I still opened my laptop regularly, given my irrational fear of the thousands of Slack notifications that I would miss out on if I didn’t. This was before I learned about Shift-Esc and had developed the emotional capacity to actually use it. And because I lack any and all self-control, the only way I could finally disconnect was by logging out of Slack on all my devices.

It was the first time in years I wasn’t surrounded by constant input, decision-making pressure, and fire alarms. I distracted myself with other technical projects, and in the absence of daily notifications, a quietness started taking over that allowed me to detach and reflect more deeply and honestly about the decision I had made.

It’s not actually stepping down

Stepping away from a position of status and authority is incredibly difficult. We’ve been conditioned to equate executive titles with success, so it’s no surprise when doubt starts to creep in that undermines your confidence. Did I fail at my job? Am I giving up and letting people down? Am I damaging my career?

But there’s a growing counter-narrative in the tech world. There is the well-known example of Mitchell Hashimoto’s decision to step down as CTO of HashiCorp to become a Senior IC. There are others too. Former Artsy CTO Daniel Doubrovkine, now Principal Engineer at AWS, Kristina Lustig, former Director of Design at StackOverflow, or Pradipta Banerjee, former CTO now Principal Engineer at Red Hat. They all shared their journey from management back to hands-on engineering. These stories seem like outliers, drowned out by the noise of LinkedIn posts celebrating promotions, but they all share an underlying theme. Each of them had reached a point where traditional definitions of success no longer aligned with their sense of fulfillment. They had confronted what psychologists call the arrival fallacy: the belief that attaining a particular goal will lead to long-term happiness.

Having now recognized this as a trap, I was able to re-frame my own decision. Instead of asking “What am I stepping away from”, I asked myself “what gives me energy, and what takes it away?”, which was much more productive. Was I really at my most impactful in back-to-back meetings, managing OKRs and team performance? Or was I just keeping the machine running, at the cost of the creative work that played to my strengths and brought me here in the first place?

Having authority vs being an authority

I’ve had frustrating experiences in my early career where I couldn’t convince people in power to address problems that seemed so glaringly evident to me, while at the same time lacking the agency to solve them in my own way. I learned that this is common among people stuck in middle management. Whenever I finally did get a position of authority, I was able to drive change quickly and get great results that way. This entrenched my belief that holding a position of authority was the key to having high impact. It’s clear to me now that this was another reason I wanted to found a company in the first place.

Over time, though, I realized that having authority and being an authority aren’t the same thing. Titles can create compliance, but not necessarily conviction. Yes, when people are contractually obliged to follow your lead, change happens fast, but I’ve found that sustained influence doesn’t come from org charts. It comes from vision, trust, and building systems people actually want to work in. Of course these aren’t mutually exclusive, but most of us aren’t really chasing authority, we’re chasing impact.

It comes down to a few simple habits. Be around when it matters, listen to people’s concerns and be their advocate, support and elevate people around you by providing input that leads to better outcomes for them, and inspire by leading by example. To me, this means being hands-on and regularly working shoulder to shoulder. Or, as one of my colleagues succinctly put it, “just sharing your wisdom and then fucking off”. Doing those things will make you an agent of change, regardless of title.

Making room for others

Founders often struggle to let go because they conflate personal value with holding on to certain responsibilities. But roles evolve, and the person who’s best for the job at one stage of a company’s growth may not be the best fit for the next. All this wasn’t just about me.

We had built a strong foundation of systems, culture, and technical vision that no longer depended on me to function. At our size and pace, we needed more leaders whose strengths lay in scaling delivery, applying repeatable management playbooks, navigating teams through organizational change, and creating endless KPI reports while keeping their sanity intact. These are things I was very capable at, but not things I thrived in, and clinging to the seat would have only limited the team. Stepping away created space for new people and new perspectives, while allowing me to focus on cross-team technical leadership, where I knew I could bring the most value to the team and the company.

I’ve always believed in embracing change, whether in our product, processes, or leadership. And I’ve always sought out opportunities to experiment, to learn from others, and be inspired by the experience they bring. Our engineering leadership team is now more distributed, with multiple Directors and Engineering Managers, and they strengthen the company in ways I couldn’t have achieved alone.

Learnings

If you’re considering a change like the one I made, there are a number of learnings that I can offer as advice.

Be honest with yourself: Why do you want a particular role in the first place? Is it impact? Perhaps the work you’ll get to do? Is it about advancing your career? Or is it the allure of Power? Money? Status? I’ve stopped judging people for wanting these things, but be honest with yourself about your motivations, and ask yourself whether they are leading you to meaningful impact and lasting happiness.

You are more than your job: It should be obvious: but you should not attach your self-worth to a role or a job title. It’s very hard to relinquish a title and not feel inadequate in a culture that glorifies titles and promotions. You can read more about how this culture has affected an entire generation in Tim Urban’s blog post on “Why Generation Y Yuppies Are Unhappy”. Real self-worth isn’t found on a career ladder; it’s in the value you create, the people you elevate, and the integrity of your actions.

Build a support network: A curse of executive leadership is that it can become lonely, as you have few peers at the company you can open up to and who understand what you’re going through. Build a professional support network outside the company. Find peers who you feel safe to be vulnerable around, and to talk honestly and openly about what you’re going through. You’ll be surprised how many people are going through similar things, and how they open up when you show a bit of vulnerability yourself.

Acknowledge the challenges but focus on the opportunities: Suddenly not being part of the “inner circle” is difficult. There’s a sense that you’re losing control and are no longer informed, but at the same time, most of the things that demanded your attention were probably the things that drove you to change your situation in the first place. As Daniel Doubrovkine put it: “I [knew] all the secrets […] and knew when someone important was quitting or being fired. This is all gone, but so are the agonizing headaches, such as not being able to tell someone that they are about to get laid off”. So you’re not missing out, you’re reclaiming your time for things that matter to you the most.

Re-design your work day: use the opportunity to redesign how you work. For example, you probably don’t have any direct reports anymore, so you have no obligations to have regular 1:1s, but that doesn’t keep you from having them, and they can be extremely useful to keep your finger on the pulse! Make them time bound, and purpose driven. They repeat for eight weeks and then end. Maybe it’s to pair weekly on architecture during big initiatives, or to coach someone hands-on through a difficult period?

You only live once: Hone in on things that matter the most, but don’t compromise on the things you love doing. Everything ends someday. The jobs, the titles, and once the last black hole has evaporated and the universe has succumbed to heat death, even your company. What remains is the journey you lived, the legacy you left, and the impact you had on the people around you.

Syncing Notion databases into Tinybird using notion-objects

2022-10-17T03:00:00-05:00

In this blog post, I want to show you how you can, with just a few lines of Python code using the notion-objects library and the Tinybird API, synchronize data from Notion databases into Tinybird data sources.

I’ve become a big fan of both Notion and Tinybird. They are excellent products and I use them daily at LocalStack. We’ve been using Tinybird as a consolidated data warehouse for a while, and query it for all sorts of analytics. We’ve also been steadily building up data in various Notion databases, including our project roadmap or customer incident tracking, that we wanted to start running queries against. So it was clear we had to start syncing data from Notion into Tinybird. I spent some time last weekend to create a library to make it easier to get data out of Notion. We now use the library in scheduled AWS Lambda functions that do the synchronization. After reading this article, you should be able to build something similar.

Prerequisites

Requirements for this:

Python 3
A Notion account
A Tinybird account and workspace
A basic understanding of the three

Creating a Notion integration

I’m assuming you have a notion account and have some familiarity with it. To create an API token for Notion, we first need to create what Notion calls an integration, and connect the integration to the database we want to synchronize. The Getting Started guide in the Notion developer docs explains this very concisely.

Here’s my notion database I use for demonstration. I also highlighted where to find the database id (needed later).

notion-objects

notion-objects is a data mapper for mapping Notion database records to Python objects. To connect to Notion, it uses notion-sdk-py, a Notion SDK for Python.

Simply install notion-objects using pip:

pip install notion-objects

With notion-objects, you can easily iterate over all records in a database, and access Notion database fields like Python object attributes. You can build your own data models and mappings, which is explained in the notion-objects README, but the default dynamic mapping works pretty well for basic use cases.

Here’s some example code.

import os
from notion_client import Client
from notion_objects import Database

def main():
	notion_token = "" # notion integration token goes here
	database_id = "" # add your database ID here

    # create the notion client
    client = Client(auth=notion_token)

    # the notion-objects database
    db = Database(database_id, client)

    for record in db:
        print(record.id, record.Name, record.Assignee, record.Status)

if __name__ == '__main__':
    main()

For my database, this prints:

10289cdc-7987-4f2d-8f6d-be8ab7d4308e Create notion workspace ['Thomas R.'] Done 🙌
44d54963-c2ef-40de-80ef-d25fe6df444f Publish blog post [] To Do
8b8dd97e-2e7f-470a-b076-3958100293f6 Write blog post about notion-objects ['Thomas R.'] Doing
964da614-f41f-4930-aed6-ca50f10603ee Take Fig on a walk [] Doing

Record objects also have to_json and to_dict converters, that will later come in handy.

Getting data into Tinybird

The events endpoint of Tinybird is convenient because it accepts NDJSON and will also create the datasource if it does not exist. So all we need is a datasource name, an NDJSON payload, and a POST request to the events endpoint.

    # build an ndjson batch that we later sync into tinybird
    batch = []
    for record in db:
        # flat=True flattens date range properties into two columns
        batch.append(record.to_json(flat=True))

    data = "\n".join(batch)

data will now contain a new-line delimited JSON (NDJSON) payload, which we can post directly to the events endpoint:

    # converts something like "My *fantastic* database" into "my__fantastic__database", which is a vald tinybird datasource name
    tinybird_datasource = re.sub('[^0-9a-zA-Z]+', '_', db.title.strip()).lower()

    # post the batch into tinybird and create the table if it doesn't exist
    requests.post(
        'https://api.tinybird.co/v0/events',
        params={
            'name': tinybird_datasource,
            'token': tinybird_token,
        },
        data=data
    )

Code so far

Let’s put together what we have so far:

import re

import requests
from notion_client import Client

from notion_objects import Database


def main():
    notion_token = "secret_"
    tinybird_token = "p."
    database_id = "c59fec7c9a4b43b0b069b0c0aa843054"

    # create the notion client
    client = Client(auth=notion_token)

    # the notion-objects database
    db = Database(database_id, client)

    # build an ndjson batch that we later sync into tinybird
    batch = []
    for record in db:
        batch.append(record.to_json(flat=True))
    data = "\n".join(batch)

    # convert the title of the notion database into a valid tinybird datasource name
    tinybird_datasource = re.sub('[^0-9a-zA-Z]+', '_', db.title.strip()).lower()

    # post the batch into tinybird and create the table if it doesn't exist
    requests.post(
        'https://api.tinybird.co/v0/events',
        params={
            'name': tinybird_datasource,
            'token': tinybird_token,
        },
        data=data
    )


if __name__ == '__main__':
    main()

If you run this script, this is what you get in your Tinybird workspace:

Syncing changes

Next we want to deal with syncing data continuously. Since Notion currently does not provide webhooks to react to changes, we need to run a scheduled synchronization job. What would this job do? One way would be to truncate the datasource, and then run the full insert every time.

Alternatively, if we want to keep track of changes, we could only insert those notion objects that have changed since the last update.

Get the time of the latest synced change

notion-objects creates a default column last_edited_time that maps to the notion page’s last edit timestamp. We could first query this from the the table using the Tinybird SQL endpoint GET /v0/sql.

    r = requests.get(
        f'https://api.tinybird.co/v0/sql',
        params={
            'q': f"SELECT max(last_edited_time) FROM {tinybird_datasource}",
            'token': tinybird_token,
        }
    )
    print(r.text)  # 2022-10-16 19:36:00

An alternative could be to use the datasource’s operations log, but this is out of scope of this blog post.

Build a dynamic notion query filter

Now we want to fetch only those notion objects from the database that have been edited since the last time the data was synced. To that end, we dynamically build a notion query filter, based on the input of the previous query. If the database doesn’t exist yet, the Tinybird SQL query may fail, so we guard against that case.

    if not r.ok or not r.text.strip():
        # probably the table was not found, so we just use None
        query = {}
    else:
        # build a query that fetches only those pages that were edited
        # since the last time the database was synced
        query = {
            "filter": {
                "timestamp": "last_edited_time",
                "last_edited_time": {"after": r.text.strip()},
            },
        }

Now you can use notion-objects Database.query method to iterate over the result:

    batch = []
    for record in db.query(query):
        batch.append(record.to_json(flat=True))

    if not batch:
        print("batch is empty, probably no data was edited")
        return

    data = "\n".join(batch)

De-duplicating data

Obviously we now have records with the same ID multiple times. Once for every sync if it has changed since the last sync. There are several ways you can deal with duplicate data in Tinybird. I recommend checking out the Tinybird guide on de-duplication strategies for the full picture.

A simple query that only returns the latest items can look like this:

SELECT * FROM task_list
ORDER BY last_edited_time DESC
LIMIT 1 BY id

Here’s the effect in Tinybird:

Final Python program

Here’s the complete Python program

import re

import requests
from notion_client import Client

from notion_objects import Database


def main():
    notion_token = "secret_"
    tinybird_token = "p."
    database_id = ""

    # create the notion client
    client = Client(auth=notion_token)

    # the notion-objects database
    db = Database(database_id, client)

    # convert the title of the notion database into a valid tinybird datasource name
    tinybird_datasource = re.sub('[^0-9a-zA-Z]+', '_', db.title.strip()).lower()

    r = requests.get(
        f'https://api.tinybird.co/v0/sql',
        params={
            'q': f"SELECT max(last_edited_time) FROM {tinybird_datasource}",
            'token': tinybird_token,
        }
    )

    if not r.ok or not r.text.strip():
        # probably the table was not found, so we just use an empty filter
        query = {}
    else:
        # build a query that fetches only those pages that were edited
        # since the last time the database was synced
        query = {
            "filter": {
                "timestamp": "last_edited_time",
                "last_edited_time": {"after": r.text.strip()},
            },
        }

    # build an ndjson batch that we later sync into tinybird
    batch = []
    for record in db.query(query):
        batch.append(record.to_json(flat=True))

    if not batch:
        print("batch is empty, probably no data was edited")
        return

    data = "\n".join(batch)

    # post the batch into tinybird and create the table if it doesn't exist
    r = requests.post(
        'https://api.tinybird.co/v0/events',
        params={
            'name': tinybird_datasource,
            'token': tinybird_token,
        },
        data=data
    )

    print(r.status_code)
    print(r.text)


if __name__ == '__main__':
    main()

Final remarks

Ideally, Tinybird partners up with Notion to provide this as a connector. Until then, we’ll need our own serverless solutions to operationalize this.

We use similar code at LocalStack in AWS Lambda functions that do the synchronization on a schedule. You could easily package this as a Lambda function and just deploy it to AWS to do the synchronization when the lambda is invoked. In fact, when I developed the deployment, I tested my Lambda function on LocalStack locally first. Look out for a follow-up on our LocalStack blog explaining how that works.

notion-objects is still under development and the API may change drastically! The next iteration will be allowing update operations on Notion objects (already works for simple properties in notion-objects>=0.4.0), to write back into Notion databases.

What we haven’t covered so far are page deletions. With the current script, we cannot remove pages from the Tinybird database - it’s append only.

Stay tuned for more!

Streaming Lectures at TUW using OBS and YouTube Live

2020-09-25T08:00:00-05:00

During the summer term 2020, the first COVID-19 related shutdown of universities caught us a bit off-guard. I was teaching Distributed Systems Technologies at TU Wien and had to postpone the first lecture. It was unclear what the TUW standards for distance learning would be. The common practice at the time were recorded slidecasts, which I didn’t find to be very engaging. So we decided to instead stream our lectures at the dates we had scheduled to YouTube live and then provide recordings of them. Because the model was successful, and I’ve been asked a few times about the setup I used, here’s a short post about it.

Successfully streamed the first DST lecture @tuvienna @dsg_tuwien from home, and did a live demo of Murphy's Law: battery of microphone died, battery of camera died... Students were still engaged with the format, and I'm totally looking forward to the next lecture. 👨‍🏫😎 pic.twitter.com/8nXoBzPUPc
— Thomas Rausch (@thrauat) March 18, 2020

Video & Audio Setup

Hardware

I don’t use any special hardware:

Laptop
HD Webcam (Logitech C920)
Cheap lavalier microphone (15 EUR on Amazon)

I used my Sony a6000 as a webcam at first (you can see it in the picture on Twitter), but the quality wasn’t that much better, so I went back to the webcam because it was more convenient.

Software

The only software I used was:

OBS Studio
LibreOffice Impress

OBS Configuration

OBS main concept is a scene composed of sources. I needed to capture my LibreOffice full-screen presentation window, as well as my webcam. OBS also allows you to place static text and images in the scene (like the university logo and the course name).

Presentation

To capture the presentation window, I opened the LibreOffice presentation, entered presentation mode (F5), alt-tabbed into OBS, and then added a “Window Capture” source of the full-screen presentation window now running in the background. You could do it with a complete screen capture, but it didn’t work properly with my multi-monitor setup. When streaming, I simply switched backed to the presentation window and tried to give a natural presentation as I would in the lecture hall.

For me that also meant standing while streaming so the delivery would feel more natural to me.

Webcam

I oriented my Webcam in a way that I appeared vertically next to the presentation. I got the idea from “goto; conference” recordings. Just create a new video capture source, place the source somewhere in the scene, right click and select “Transform > Edit Transform”. Then just crop and position until it nicely lines up with your presentation source.

Streaming

There are lots of tutorials on how to stream from OBS to YouTube Live, this one for example.

Basically, after activating the live stream feature in YouTube (takes 24 hours), you schedule a live stream in your YouTube Live studio, find the “Streaming Key”, which you then enter in your OBS configuration. When you press “start streaming” you should see the preview in YouTube studio. Once you are ready, you can press “Go Live” in YouTube.

My streams as well as the recordings were “unlisted”, meaning you can access them with the link, but they cannot be accessed via the YouTube search or video suggestions.

Editing

I didn’t edit much, I only cut out the, short breaks, coughs, and rambling I sometimes tend to when I don’t have a script. The YouTube studio editor is absolutely sufficient for that. No editing software needed. It takes an hour or so after you are down until the edited video appears.

Timestamps

Adding timestamps to the video description is a bit of effort, but they are very useful for viewers to navigate the recording!

When they are in the video description with a bit of text, YouTube automatically creates chapters in the video progress bar.

Conclusion

Overall OBS and YouTube Live make it extremely easy to stream lectures and provide recordings. For audience participation, I used the live chat, but a lot of lecturers already make use of richer online participation tools.

By now many lecturers have to do online lectures in some way, and have found a concept that works for them. The key points that made the lectures work for me were:

Giving a live lecture at scheduled dates and provide recordings, rather than pre-record the lecture. Pre-recording is hard, and live streams are more engaging for students.
Standing while giving the lecture.
Not using the built-in webcam/laptop microphone
Making one pass through the recording to a) create timestamps, b) trim out unnecessary parts, c) reflect on my presentation of the content.