Product Manager Day 2024: Creating an Authentic Conference Experience

On a sunny and rainy Norwegian summer’s day, I woke up excited and early to host our first ever mini conference for 80 Product Managers in NAV. Product Manager Day 2024 was finally happening! Working within budget restrictions and high ambitions to create an authentic conference experience, my colleagues Sigrun, Ingrid og Yvonne and I had spent three previous months designing the program together with the participants, on top of other tasks. Our aim was to boost the strong product managment community within our organization and utilize the competence and engagement that was already present. At the end of the day, the participants rated the experience a total score of 4.74 out of 5 😍. We couldn’t be more proud of the magic we created together with our PM community!

Beside our typical main ingredients for organizing events (structure and planning, facilitation experience, collaboration, and fun 🥳), this post elaborates on five key lessons.

Sigrun and Marianne excited and honoured to welcome 80 amazing PMs to our conference!

Lesson #1: Fewer organizers are more efficient 🚀

After the four organizers had agreed on goals and budget for the event, Sigrun and I had the opportunity to put in some extra effort, and thus took lead of the process. Collaborating in a well functioning pair is super efficient (as I have written about before), and Sigrun and I knew from previous experience we made a great team. A pro-tip when you are co-facilitating or co-organizing is to make sure you and your partner align on ambitions and quality, and support each other.

Now and then we checked in with our sponsor and the other organizers to get feedback and help. When the big day was approaching, we were all in sync and could easily split the rest of the tasks between us to be even more efficient.

For planning tools, we used Trello, Slack, and Mural. In the beginning, the digital whiteboard functioned as a common planning tool, but as Sigrun and I started digging deeper in to details, the board soon became too messy for anyone else to keep track of. We compensated with regularly updating and involving the rest of the organizers on Slack and in weekly meetings.

One of the risks we took was the possibility of one of us getting sick or absent. We barely managed to organize everything on time, and it’s a vulnerability we need to consider for our next big event.

Lesson #2: Details can make the difference, but avoid rabbit holes 🐇

Aiming to create the same feeling you get at an actual conference, Sigrun and I sometimes went a bit over board with the nice-to-have details. We AI generated our own playlist, our own logo 🐙, created stickers, a bingo competition and filled 80 goodie bags with branded merch for each participant. Working late, having too much fun playing with the details, we sometimes had to ask ourselves this question to get our priorities straight:

If we had to organize the event tomorrow, what would we be working on today?

Sigrun and Yvonne providing name tags and merch upon registration.
Bingo competition.

Lesson #3: Create a feeling of abundance and FOMO 🤹‍♀️

The most import ingredient to mimic that authentic conference feeling was for us to pack the program with parallel tracks, to create that frustrating feeling you get when you are forced to miss lots of interesting talks. That way, you have more to discuss during breaks and a stronger incentive to ask questions, network and connect. It also helped shift and rebuild the energy between each session, because it was always a new group attending.

Sigrun leading one of the parallel workshops.
Ingrid leadning the other workshop.

Lesson #4: Invest in your own talent 👨‍🎤

To kickstart the day and bring in some inspiration from outside our company domain, we invited two fantastic keynote speakers from Aidn, Kim and Marius. Having two impressive product people share their honest experience with us lifted the quality of the event. At the same time, we were conscious about our own talent sitting in the audience. When we first sent out the invitation, we invited the participants to contribute, and 16 product managers immediately raised to the challenge. That allowed us to have 16 lightening talks in the parallel tracks.

Our top priority was to be of service to the product managers that were contributing their wisdom, effort, and heart in their lightening talks, to make sure they felt confident when they entered the stage. Sigrun and I offered mentoring, dry run sessions and feedback. At the time of the event, the rest of the audience were instructed to give positive feedback to our lightening speakers, to train our ability to identify each other’s strengths, and to offer a gift of appreciation to our talented pool of speakers. According to positive psychology, focusing on our strengths will allow us to perform better than focusing on our weaknesses.

Positive feedback to one of our awesome lightning speakers.

Lesson #5: Make the rules of the game clear from the start 💎

One of my biggest learning and reminder was to not underestimate the need for explaining rules of new concepts. I have run several Open Space sessions in my organization, also with larger groups, but not with this community. Many had never attended an Open Space before, and I assumed the rules were clearer than they were. Next time, I will share some information beforehand, and explain from the beginning what it means to propose a topic, to make it safe from the start to engage. Once we got going, the participants loved it, and the group discussions were fun and energetic. With the proper framing and introduction, I highly recommend Open Space as a concept!

Explaining how Open Space works.
The most engaged and supportive audience ever 👏

Have you organized big events, and what’s your learning experience? What do you take away from our learnings? Where do you disagree? In what other context do you find these and other learnings applicable?

Product Manager Day 2024: Creating an Authentic Conference Experience

What does Agile and DDD have in common?

This evening I attended an inspiring meetup The pillars of Domain Driven Design with Marco Heimeshoff. I am quite new to DDD (Domain-driven Design), and Marco Heimeshoff did a great job explaining it.

In short, DDD is about translating business domain language into code, using one obiquitous language to create a bounded context in which to reason about the domain. This creates coherence and reduces risk and complexity. DDD can also create motivation, as it enables autonomy (through bounded context), mastery and purpose.

programmer2
This picture illustrates how to not do DDD. Using DDD, the developer would implement the code using the same words as the user, like sofa  picture and table.

This talk has got me hooked and I am definitely going to learn more about DDD.

However, being an agile enthusiast, I couldn’t help but noticing the similarities between DDD and Agile. You could basically just swap the word DDD with Agile, and it would have made perfect sense.

From just this one talk, I gathered 10 examples where I felt that the topic could just as easily have been about Agile as DDD.

Example 1

What DDD/Agile is not:

  • New
  • Hard
  • Overhead
  • Only for complex domains

Example 2

It’s a dance, not a march (if someone gives you a three steps guide to DDD/Agile, it’s a hoax).

ddd is a dance not a march

Example 3

DDD/Agile gives you the most benefit in the complex and complicated domain, but can also be valuable in the other Cynefin framework domains.

Example 4

Who should learn DDD/Agile? Everyone involved in the software development process.

Example 5

There is a bunch of methods (that consultants will try to sell you), but they are not the core of DDD/Agile. Only use them if they are useful to you in your context. If you find other more suitable methods, please use them instead.

Example 6

DDD/Agile changes everything in the company (like how we are organized, the way we work, roles). DDD/Agile is a mind turner.

Example 7

The more you try to prove that DDD/Agile works, the more it backfires because people will protect their identity (their existing roles).

Example 8

You are not a DDD/Agile person. You are a problem solving person, aiming to add business value.

Example 9

The first rule og DDD/Agile is: You do not talk about DDD/Agile.

If you use branded names, people will get too hung up on the methods and the practicalities, and lose sight of the underlying purpose (and expect it to come in a box with a certificate).

Example 10

The way to implement DDD/Agile is through small controlled experiments.

This is just the examples I had time to scribble down during that one talk. What other similarities can you find? What are the significant differences?

What does Agile and DDD have in common?

Five Forces Against Agile

Let’s say you had to choose a default strategy for developing software:

  • bureaucracy, waterfall development, centralised decision-making and micromanagement?
  • Or a culture of trust, autonomous cross-functional teams, continuous delivery and iterative development?

Seemingly, people in the IT-industry now have come to recognise the latter as a more successful strategy. We know that agile works. Even in the public sector. Then why is the transformation from slow, rigid and expensive processes to a more successful, cost efficient way of generating better value so hard?

Sure, there are obstacles in factors like these:

  • Budgets
  • Contracts
  • Architecture
  • Organization
  • Legacy systems
  • Tools and technologies

These are certainly real barriers for an agile transition. However, they are all tangible, visible and, dare I say it, easier to deal with than the more complex, darker forces lurking in the shadows of the human mind (they are not really dark forces, but a normal part of our human nature and survival strategies).

In this post I suggest five forces I see working against a better way of developing software. All of them might not be relevant in your context and some are stronger or weaker depending on your context. If none of them are familiar, consider yourself lucky.

1. Individuals resist being changed

If you work in a startup or with innovation, you might be familiar with the diffusion of innovations. Only 16% of people are considered Innovators and Early adopters. Humans have a history of surviving by staying with the pack and following the majority, and most people need serious consideration to accept new ideas. For organizations, the adoption to new ideas are even more complex.

change

2. People enjoy power

Agile is about autonomy, learning by doing and letting the team decide how they solve the problem. This requires a large dose of trust, not just inside the team but from management and leaders. Agile does not work very well in a command and control environment.

Unfortunately, people who are used to being in control and exercise micromanagement will naturally find it hard to let go of their control. It requires a shift from Theory X to Theory Y, where not only leaders learn to trust but the team member stop playing the blame game and learn to take responsibility.

3. “We would rather be wrong than uncertain”

Agile are optimized for changing requirements and uncertainty. Humans are optimized for categorizing data and generalizing problem solving. This gives us the warm and fuzzy illusion of control. We are extremely bad at dealing with uncertainty. As Dan North says it: We would rather be wrong than uncertain.

The irony is that agile sceptics often mistake agilists for being daredevils and risk takers, when in fact agile is handeling risk in a much safer way than what carving assumptions into stone is.

One consequence of this is that we are tricking ourself into believing we can predict the future with mental images based on a weak analogies.

The House Analogy

One often used analogy for software development is building houses. This gives us the illusion that we are building something concrete which we should plan in great and accurate details up front, and it will in fact turn out that way. And the bigger the better. It also implies that demolishing the house and starting over is expensive, when in fact, deleting code and starting over is literally done by a keystroke.

The Elephant Analogy

Another analogy we often use is comparing projects to elephants. “How do you eat an elephant? One bit at a time.” This gives us the illusion that we know exactly how the end result is going to turn out, and we can just split the problem into 100% accurate increments and assemble all the pieces perfectly together at the end. When in fact we are trying to grow a new creature that doesn’t exist yet and no one has ever seen before.

43-eating-elephant

 

4. Agile threatens The Establishment

This is an often overlooked consequence of following the agile principles. Delivering value early and frequently has a significant impact on how we are organized and what skills are needed. Our goal is to get real feedback early. “Working software is the primary measure of progress”. Instead of getting written specifications handed over, developers are working face-to-face with business people and user representatives. We are in the complex domain of the Cynefin framework and apply a probe, sense and respond approach. This greatly reduces the need for detailed planning, estimations and comprehensive documentation up front. Consequently, it reduces the need for coordinators, managers and administrators.

mvp
http://blog.crisp.se/2016/01/25/henrikkniberg/making-sense-of-mvp

 

It can then seem like a contradiction when we choose to outsource programming, making it harder to collaborate through geographical distances and cultural barriers. At least it generates more work for management. Christin Gorman has an excellent point about this.

5. Agile is small and cheap

Agile is in a sense about keeping it small and simple and eliminating waste. Simplicity and downsizing does not generate the same amount of need for middle managers, coordinators, documentation, meetings and administration. Yes, we are saving costs and that is a positive force for the company paying for the IT related services. But on the other side we are also cutting income for the people making money out of those very activities that does not generate direct value.

Agile generate less income for management consultancies than the waterfall model (unless you are selling agile coaching, courses and certifications). Unfortunately, money is power and this is a strong force I think often is overlooked by somewhat naive techies. Budgeting and economy is not our favourite topic (and economists  on the other side don’t bother with understanding technology either when they outsource core business to India hoping for cost savings).

And let’s be honest. For humans in general, smaller projects are not as impressive on our resume.

“Don’t fight stupid – Make more awesome”

Introducing and sustaining agile can sometimes seem like a dark and long path through frustrating and complex people issues. Introducing change to a business requires great patience and a positive attitude. But it is also necessary to understand the challenges and unfavorable conditions working against you when all your best effort, logic, reasoning and patient are not getting you any closer to your goal. Recognizing the human drivers at play can make them easier to tackle and to know when to stop banging your head against the wall. Maybe you will even find a way to use them to your advantage?

Taking a deeper look at these human forces will also make you realize that all of them are a natural part of our nature and not as evil as they first might appear.

Fortunately, there are lots of techniques for overcoming people issues. Fearless Change (a wonderful read) by Linda Rising and Mary Lynn Manns contains powerful patterns that will make your mission towards change more fun and more efficient.

Besides, being the most adaptive creature on earth, humans have the capability of learning new skills and adopting to change. Bosses are becoming leaders, test managers are becoming an integrated part of development teams and project managers are providing their skills as coaches and scrum masters. And as I have learned from coaching theory and from reading Fearless Change: In order to introduce change, you have to genuinely believe in the hidden abilities and good intentions of people.

Five Forces Against Agile

Is DevOps about to make the same mistake as Agile?

DevOps is in many ways the popular little sister of Agile. She is not a completely new, rebellious generation, like Agile was to his mother Waterfall, but she looks up to her older brother and has a some opinions of her own.

Coming from the same family, DevOps and Agile have similar values and principles. The highest priority of Agile is to satisfy the customer through early and continuous delivery of valuable software. To create valuable software, Agile insists that business people, customers and developers collaborate and work together. DevOps agree, but her main concern is that Agile does not emphasize collaboration throughout the software life cycle as a whole, all the way to production support. She wants to collaborate with IT operations as well.

The highest priority of Agile is to satisfy the customer through early and continuous delivery of valuable software […]. DevOps agree […].

Agile has already lived long enough to see the consequences of his preachings. Agile principles were picked up by well-intentioned people (and inevitably people with economical motivations as well), turning them into methods and rituals that everyone wanted to join in on. But somewhere along the road paved with good intentions, Agile practitioners took a wrong turn, and the frustration towards Agile started growing.

In the history of Agile, we have seen some unfortunate unintended consequences:

  • Projects not producing a single line of documentation because working software is valued more (this has also been said to be the reason for the decline of UML)
  • Projects being rewarded only for delivering value to the end-user on time – not the quality of the product
  • Customers not specifying any requirements up-front because “You are supposed to welcome changing requirements late in development” or “Isn’t ‘agile’ the just another word for ‘flexible’?”
  • Product owners not representative of the end-users prioritizing features and giving feedback on the product alone
  • Scrum teams having worthless daily standups and other Agile rituals that no one really sees the point in
  • Cross-functional Scrum teams where developers are forced to pair-program and rotate all the tasks, turning specialists into miserable, average performers

Ironically, Agile processes and tools became the main focus for many of its followers, even though the first value of Agile is individuals and interactions over processes and tools. Many practitioners also seem to skip the basic understanding of the values and principles, and applied them with no pragmatic sense at all.

Ironically, Agile processes and tools became the main focus for many of its followers, even though the first value of Agile is individuals and interactions over processes and tools.

Agile received many hate mails because of this. Is DevOps in store for the same kind of misuse and harassments?

A common interpretation of DevOps is that the people implementing the software should be the same people running it. This way, developers are accountable for what happens after release as well. This will lead to better quality, as the developers have an interest in making the system less error-prone and easy to maintain. In a context with virtualization, cloud computing, automated tests and quick and easy deployment, this implementation of DevOps can be a great success.

However, if your organization is a large, complex bureaucracy with old infrastructure and legacy systems where the different IT operations require deep, specialized knowledge, firing the entire IT operation department and having the developers take over might not be a great idea. In this case, instead of spreading the knowledge thin across the different domains of expertise, collaboration between experts might be a better approach to DevOps.

DevOps, like Agile, has some potential pitfalls, like turning specialists into mediocre performers. But even if DevOps is about to make the same mistake as Agile, we cannot blame a concept for our failures. We as practitioners need make sure that everyone involved in the process grasp the values and principles behind what we are doing, and remain pragmatic about it. Us humans apparently need to remind ourselves constantly why we are doing what we are doing not to get too carried away.

We as practitioners need make sure that everyone involved in the process grasp the values and principles behind what we are doing, and remain pragmatic about it.

DevOps does not have to make the same mistake as Agile, as long as we as a community take responsibility for our mistakes with Agile and learn from them.

Is DevOps about to make the same mistake as Agile?