<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Hagen Schendel on Medium]]></title>
        <description><![CDATA[Stories by Hagen Schendel on Medium]]></description>
        <link>https://medium.com/@hagen.schendel?source=rss-c0ee20032e42------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*-VeIqgLkzy48GGu-JI0S0A.jpeg</url>
            <title>Stories by Hagen Schendel on Medium</title>
            <link>https://medium.com/@hagen.schendel?source=rss-c0ee20032e42------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 16:33:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hagen.schendel/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Set Up a Team for Failure]]></title>
            <link>https://medium.com/@hagen.schendel/how-to-set-up-a-team-for-failure-74d6649882d4?source=rss-c0ee20032e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/74d6649882d4</guid>
            <category><![CDATA[team-topologies]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[team-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[failure]]></category>
            <dc:creator><![CDATA[Hagen Schendel]]></dc:creator>
            <pubDate>Tue, 07 Feb 2023 12:48:38 GMT</pubDate>
            <atom:updated>2023-02-07T13:41:31.779Z</atom:updated>
            <content:encoded><![CDATA[<p>Software development teams can fail in so many ways, here are the top 9 ways to ensure they do ;-)</p><figure><img alt="Game Over screen typical for old video games" src="https://cdn-images-1.medium.com/max/800/1*EGZi9R-fti45AFOEcu9eoA.png" /><figcaption>Game Over Screen (by <a href="https://opengameart.org/content/game-over-screen">opengamearts</a> user Angry Amish)</figcaption></figure><p>This article is written for the perspective of those with malicious intentions. But even for those with good intentions, in this format, our negative human nature might yield a better grasp of the failures of team setup.</p><h4>1) Built-in Dependencies on Others</h4><p>Teams usually need certain skills or permissions to be able to fulfil their mission. When they have all the needed skills and permissions within their area of work, they do not have to negotiate with or wait for others when going about their daily business.</p><p>You can use this to slow a team down. If critical skills or permissions are moved to other teams, they will have to negotiate for support from there on almost every thing they do. For example, if your architecture for frontends and backends is so specialized you need different kinds of developers, you can make sure that a team has only Frontend Developers. They cannot deliver anything on their own! This completely undermines the cross-functionality requirement necessary for many Agile methods such as Scrum! Perfect!</p><h4>2) Block Real Time Cooperation</h4><p>If all team members sit in the same, or adjacent timezone, it is easy for them to cooperate in real time. E.g. two developers might decide to “pair” on implementing a certain feature. Or the team might gather ad hoc to unblock a work item by taking an important technical decision. They might collaborate in fixing an urgent operational issue.</p><p>You can completely derail this productive behaviour by distributing them among incompatible time zones. The perfect split would be Central Europe and New Zealand which makes for a 12 hour difference. But a 6 hour difference already works unproductive wonders.</p><h4>3) No Agency, No Autonomy</h4><p>If a team has agency and autonomy within a clearly defined mandate, they will be faster, because within their mandate they can take decisions on their own, not having to wait on others. Usually these decisions would be quite good, as the team should build up expertise in their area. Also, because they are able to decide on their own, they will develop a sense of responsibility.</p><p>Undermine this by making sure they cannot decide anything on their own, and they feel it. E.g. make sure that technical decisions are handed down by “software architects” outside the team, preferably the kind of architect not involved in actual coding. Also make sure that the team cannot change their work process on their own but have to negotiate with one or preferably even more managers. This will demotivate them and prevent them from feeling responsible for their area of work.</p><h4>4) Unclear Responsibilities</h4><p>In the ideal world, development teams have clear responsibilities. Even better when they are clear from a customer perspective, such as a team being responsible for a digital product, a website, or a website functionality (e.g. search). Clear responsibility usually means a clear mandate. You may even hand over the responsibility to continuously improve a product over to a single team. Ducking away is not possible. Blaming others is not possible. The team will usually raise up to the challenge, and the product and its customers will greatly profit.</p><p>All this can be prevented. Make sure the responsibilities are unclear, and even more, ensure they do not make sense from a customer perspective. E.g. make a team responsible for an architectural layer such as “data” or “backend”, and make sure it is defined as fuzzily as possible. It also helps when responsibilities overlap, creating potential for conflict.</p><h4>5) No Basics</h4><p>One way to make teams productive is to have the basics taken care of. E.g. if you have some central team maintain a Gitlab instance or some other collaboration and continuous integration environment, with the basics taken care of, all other teams can focus on their area of work.</p><p>To avoid this high level of productivity, make sure all teams have to take care of the basics on their own. Ideally this will slow them down, and also create a very heterogenous environment that further complicates cross-team collaboration.</p><h4>6) Hierarchy within the Team</h4><p>The <a href="https://scrumguides.org/scrum-guide.html">Scrum guide</a> tells us: “Within a Scrum Team, there are no sub-teams or hierarchies. It is a cohesive unit of professionals focused on one objective at a time, the Product Goal.” This is done to foster goal-oriented collaboration, and take out any countering “force” such as status, turf, or pandering to higher-ups.</p><p>To subvert this productive collaboration, make sure to introduce hierarchies and special roles. E.g. designate a leader whom a part of the team, but not all, have to defer to. If all of the team would report to the same leader, this leader would be accountable for the whole team’s success, which would be productive, so it is better to have some partial fiefdoms within the team creating a lot of friction. Make sure there are special roles assigned for everything from UX, design, frontend, backend, to QA, so there are many turfs to defend. This will slow down development considerably.</p><h4>7) Unworkable Team Size</h4><p>Adding a new team member means adding as many “communication channels” as there are existing team members. Depending on the nature of the team’s work, already three members could make for a performing team. Some people say that a team should not grow beyond six members to stay productive, the Scrum guide sets the upper bound at 10. What is clear, is that collaboration becomes harder the more people there are. On the other hand a team that is too small might miss skills, or might be easily blocked by a single team member’s absence due to vacation or sick leave.</p><p>Exploit this by bloating the team up to 12 or more members. Then watch them get stuck in all the friction their communication overhead creates. Or shrink a critical team to two or three members and watch them struggle.</p><h4>8) Bad Tools</h4><p>Tools can make collaboration so much smoother. In a colocated team, a whiteboard that is owned just by the team can be such a tool. In today’s remote teams, it means mostly digital tools. A digital calendar used by all team members should be used to plan events. It should be easy to set up a video call with many members. There should be a tool such as Miro that takes on the job of the old physical whiteboard. Hypertext documentation should be easy to create. New ideas and concepts can be co-written in a nice tool such as Google Docs. Often, there is a mix between tools used by all teams in a company, and tools a team finds to be productive for their area of work.</p><p>So you can use this to make collaboration harder. For remote teams, make sure just one (or no) team member can set up video calls in your conference system. Make sure contractor team members have restricted tool access. Give the team the worst tools possible, or configure them to be a collaboration roadblock. Microsoft Teams stands out in that it gives you so many options to do so. If you use JIRA or another workflow management tool, make sure the team cannot edit its own process. Insist documentation and concepts to be stored on an old-fashioned file share to create a versioning and editing nightmare.</p><h4>9) Complicated Architecture and Technology</h4><p>Teams are most productive when the architecture, frameworks etc. “work for them” and make their lives easier. Then there are technologies that are hard to master, or increase the likelihood of bugs. Wicked tongues say Facebook only published React to slow down everyone else, though its ease of use has presumably improved over time.</p><p>A good way to slow down a team is to combine multiple hard or error-prone technologies into a tech stack from hell. This makes sure it is hard to recruit someone with enough experience to be productive. It also means that most team members are constantly struggling with the tech stack, and thus cannot really focus on understanding the product or the customer. When you also make sure the architecture (remember, to be handed down by architects who do not code) is unnecessarily complex, this will really bog them down. E.g. to introduce a new data field in a business entity, a team member should have to make changes in no less than six unrelated locations of the code base. Circular dependencies also can work wonders in perpetuating dysfunction.</p><h4>Conclusion</h4><p>My hope is that you, dear reader, have read this article as the work of humor it was intended to be. You might remember this list when involved in a re-organization of teams at work, because it covers many things that can be done right or wrong when designing an organization’s team topology.</p><p>I am sure you have encountered many more methods of making a team less productive. Feel free to add them as a comment!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74d6649882d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to securely transfer files over SSH into a Docker Container]]></title>
            <link>https://medium.com/@hagen.schendel/how-to-securely-transfer-files-over-ssh-into-a-docker-container-9d90c45f9dbb?source=rss-c0ee20032e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d90c45f9dbb</guid>
            <category><![CDATA[ssh]]></category>
            <category><![CDATA[file-transfer]]></category>
            <category><![CDATA[sshd]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[rsync]]></category>
            <dc:creator><![CDATA[Hagen Schendel]]></dc:creator>
            <pubDate>Tue, 15 Nov 2022 08:45:18 GMT</pubDate>
            <atom:updated>2022-11-15T08:45:18.458Z</atom:updated>
            <content:encoded><![CDATA[<p>If you really must set up file transfer in our out of a Docker container, here is how to do it.</p><figure><img alt="illustration of a person carrying a paper file in front of a shipping container" src="https://cdn-images-1.medium.com/max/1024/1*pdctlOxFg3kGkl1q-EGMxA.png" /><figcaption>How the <a href="https://www.craiyon.com/">Craiyon</a> AI illustrates this topic</figcaption></figure><p>You are not supposed to ssh into a container because there are usually better mechanisms for an interactive shell when debugging a container, such as kubectl attach, or the Docker Desktop terminal. You are not supposed to transfer files to and from a container, because a normal container does not keep state, and often it is better to access the storage directly. But, as you are reading this, you might have a reason. Such as the container needing to expose some files from a mounted disk you cannot access otherwise.</p><h3>Basics</h3><p>I am referring to two different places to place the setup, and it is important to understand the difference</p><ul><li>Into the <a href="https://docs.docker.com/engine/reference/builder/">Dockerfile</a> (or Containerfile if you use <a href="https://podman.io/">Podman</a>) you can put everything that builds the container image. You do not put there any configuration or credentials that should not be part of the image. You do not want your SSH keys etc. be lying around in your Docker registry. You also do not want to rebuild your containers when you need to change credentials.</li><li>Into the <a href="https://docs.docker.com/engine/reference/builder/#entrypoint">entrypoint</a> script which is run when the container is booted you can put everything that depends on configuration or credentials. These are only injected into the container as environment variables when it is run.</li></ul><p>That being said, your Dockerfile should install the distro’s package for OpenSSH server part, especially sshd. Debian, Ubuntu, and also Alpine call it openssh-server. This could also work with some other SSH stack, but I am using OpenSSH-specific features in this article.</p><h4>User Setup</h4><p>For all file transfer roles, it makes sense to create a dedicated user. You can do this in the Dockerfile like in this example for the user backup. The explanatory comments would need to be deleted in a real Dockerfile.</p><pre>RUN set -eux; \<br># Create user with fixed uid so file ownership does not change.<br># You might want to keep uids and gids the same as on the client system<br># depending on your use case.<br>    useradd -m -s/bin/bash -u 1200 backup; \<br># set password to the impossible &quot;*&quot; so user is not locked <br># but cannot login using a password<br>    usermod -p &quot;*&quot; backup; \<br># create .ssh directory with correct permissions<br>    mkdir /home/backup/.ssh; \<br>    chown -R backup:backup /home/backup/.ssh; \<br>    chmod 0700 /home/backup/.ssh</pre><p>The recommended way to authenticate is through public key authentication which is also why the user does not get a password. You can generate a key pair for each user using ssh-keygen and then provide the public key as an environment variable (USER_BACKUP_SSH_KEY_PUB in the example) to the container. In the entrypoint script, use it to create the user’s authorized_keys file in the container that sshd uses to authenticate the user using a key pair:</p><pre># write into authorized_keys file<br>echo &quot;$USER_BACKUP_SSH_KEY_PUB&quot; &gt; /home/backup/.ssh/authorized_keys<br># set permissions<br>chown backup:backup /home/backup/.ssh/authorized_keys<br>chmod 0400 /home/backup/.ssh/authorized_keys</pre><p>Do not forget to distribute the private keys to the client machines, and to chmod them so only the owning user can access them (e.g. 0600 to read and write).</p><h4>Host Keys</h4><p>Your container is something that gets thrown away. Still, SSH has this concept of cryptographic host keys, to ensure that after the first time you have connected to an SSH host, the next time it is really the same. Host keys are generated during the OpenSSH server installation and stored under /etc/ssh. In case of a container this means whenever your Docker image is being rebuilt. Not good. It is better to provide the host keys to the container as environment variables, e.g. from a Kubernetes <a href="https://kubernetes.io/docs/concepts/configuration/secret/#ssh-authentication-secrets">Secret</a>. Putting something like this into the image’s entrypoint script creates the key files from environment variables:</p><pre>echo &quot;$MY_SSH_HOST_ECDSA_KEY&quot; &gt; /etc/ssh/ssh_host_ecdsa_key<br>echo &quot;$MY_SSH_HOST_ED25519_KEY&quot; &gt; /etc/ssh/ssh_host_ed25519_key<br>echo &quot;$MY_SSH_HOST_RSA_KEY&quot; &gt; /etc/ssh/ssh_host_rsa_key<br># sshd REQUIRES you to set the private keys&#39; permissions to 0600<br>chmod 0600 /etc/ssh/ssh_host_*_key</pre><p>You can create the keys using ssh-keygen like this:</p><pre># -C sets the key comment, -t the key type (here: ECDSA)<br>ssh-keygen -C host_key -f ssh_host_ecdsa_key -t ecdsa</pre><p>This will generate a private key file and a public key file (ending with .pub). You only have to set the private key as an environment variable. Caution: Depending on how you store and handle your secrets that get injected as environment variables, the line breaks in a SSH private key might cause trouble. A way around is to encode them into Base-64 with the base64 command, and decode them in the entrypoint script like this:</p><pre>echo &quot;$MY_SSH_HOST_ECDSA_KEY_BASE64&quot; |base64 -d &gt; /etc/ssh/ssh_host_ecdsa_key</pre><p>Also, if you want to save effort, you do not need to provide host keys for all three types, if you explicitly set the host key file in the SSH server configuration file:</p><pre>HostKey /etc/ssh/ssh_host_ecdsa_key</pre><p>In the Dockerfile, make sure to delete the unnecessary host keys generated during the package installation:</p><pre>RUN rm -rf /etc/ssh/ssh_host_*</pre><h4>SSH Server Configuration File</h4><p>Last but not least you will need a custom /etc/ssh/sshd_config file. Use the default file installed with the package as a template, but let me suggest a few adjustments:</p><pre><strong><em># Explicitly allow only certain users</em></strong><br>AllowUsers backup<br><br><strong><em># If you want the container to expose a different port than 22</em></strong><br>Port 40022<br><br><strong><em># no root login</em></strong><br>PermitRootLogin no<br><br><strong><em># no password login (key pair login only)</em></strong><br>PasswordAuthentication no<br><br><strong><em># PAM is not necessary in our simple setup</em></strong><br>UsePAM no<br><br><strong><em># No X11 forwarding needed</em></strong><br>X11Forwarding no<br><br><strong><em># Comment out or delete the AcceptEnv stuff, as it is not needed</em></strong><br>#AcceptEnv LANG LC_*<br><br><strong><em># Comment out the subsystem sftp if it is uncommented</em></strong><br>#Subsystem       sftp    /usr/lib/openssh/sftp-server</pre><p>In the Dockerfile, make sure to copy the sshd_config file into the image, and expose the port you have chosen for SSH:</p><pre>COPY files/sshd_config /etc/ssh/sshd_config<br><br>EXPOSE 40022</pre><h3>Option A: SFTP</h3><p>Now it is time to pick a file transfer mechanism. OpenSSH’s sshd has a nice builtin way to safely expose a dedicated directory using <a href="https://en.wikipedia.org/wiki/Secure_file_transfer_program">SFTP</a>. So if SFTP is sufficient, this is the way to go. You can modify the sshd_config file as follows:</p><pre># Restrict SSH session to specific directory<br>ChrootDirectory /some/folder<br># Make sure you can only use sftp<br>ForceCommand internal-sftp<br># Activate the internal-sftp subsystem for sftp<br>Subsystem sftp internal-sftp</pre><p>Please note that for ChrootDirectory to work, you need to use the internal-sftp subsystem, or otherwise set up a full <a href="https://en.wikipedia.org/wiki/Chroot">chroot</a> sandbox.</p><p>Now, assuming you have the container running locally and exposed SSH at non-standard port 40022, you can sftp interactively into the container like this:</p><pre>$ sftp -P 40022 -i /path/to/private/keyfile backup@localhost</pre><p>The working folder will be /some/folder (as specified under ChrootDirectory), but in sftp it looks like/.</p><h3>Option B: restricted rsync</h3><p>For backup or synchronization jobs, rsync is often the tool of choice. If you want to use that, you can opt for a different approach: Use the OpenSSH extensions to the authorized_keys file format to restrict the SSH user to rsync within a designated folder. rsync provides the rrsync command for this use case.</p><p>Using the example from above, the file /home/backup/.ssh/authorized_keys would then look like this, prepending the key with restrictions:</p><pre>restrict,command=&quot;/usr/bin/rrsync /some/folder&quot; ssh-rsa AAAA....</pre><p>You can generate the authorized_keys file in the entrypoint script like this:</p><pre>COMMAND=&#39;restrict,command=&quot;/usr/bin/rrsync /some/folder&quot;&#39;<br>echo &quot;$USER_BACKUP_SSH_KEY_PUB&quot; | sed -e &quot;s#^\(.\)#$COMMAND \1#&quot; &gt; /home/backup/.ssh/authorized_keys<br>chown backup:backup /home/backup/.ssh/authorized_keys<br>chmod 0400 /home/backup/.ssh/authorized_keys # read only for user</pre><p>In the sshd_config make only a small adjustment to avoid passing locale environment variables, as they cause trouble for rsync, as protocol errors:</p><pre># Do not allow client to pass locale environment variables<br>#AcceptEnv LANG LC_* # comment out AcceptEnv!</pre><p>Make sure you do not have the configuration changes from the SFTP setup above in the sshd_config, as it conflicts with this setup.</p><p>Be aware that the security of your setup now depends on the AllowUsers statement in sshd_config and on the contents of the user’s authorized_keys files.</p><p>In the Dockerfile, you need to install the distro&#39;s rsync package.</p><p>Now go to the client and try out rsync:</p><pre>$ rsync --rsh=&quot;ssh -i /path/to/private/keyfile -p40022&quot; \<br>   /some/folder/test/ backup@&quot;$CONTAINER_HOSTNAME&quot;:/test</pre><p>This would synchronize the folder /some/folder/test on the client machine into the folder /some/folder/test on the container. The directory argument to rsync is replaced with / in the target path, similar to the chrooted SFTP above. In real life you would pick a plethora of options to rsync depending on the use case, but that is another story.</p><p>Happy SSHing!</p><h3>Troubleshooting</h3><p>Troubleshooting services like sshd in a container needs a bit of preparation. sshd logs into the syslog. But most container setups do not have the plumbing for that. On Debian or Ubuntu you can solve this by installing rsyslogd:</p><pre>$ apt-get install rsyslog<br>$ service rsyslog start<br>$ service ssh restart</pre><p>Afterwards, sshd will log login failures into /var/log/auth.log.</p><p>If the level of detail is not sufficient, you can try to increase the log level in /etc/ssh/sshd_config:</p><pre>LogLevel DEBUG</pre><h3>Further Reading</h3><ul><li>If you use Kubernetes, there is a <a href="https://betterprogramming.pub/how-to-ssh-into-a-kubernetes-pod-from-outside-the-cluster-354b4056c42b">good article</a> from Sandeep Madamanchi explaining how to set up a LoadBalancer service for SSH.</li><li>The Arch Linux Wiki provides good advice on <a href="https://wiki.archlinux.org/title/OpenSSH">configuring and hardening OpenSSH</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d90c45f9dbb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Properly Setting up a Scheduled Cloud Function in Firebase]]></title>
            <link>https://medium.com/@hagen.schendel/properly-setting-up-a-scheduled-cloud-function-in-firebase-e70219cff49c?source=rss-c0ee20032e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/e70219cff49c</guid>
            <category><![CDATA[cloud-functions]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[firebase]]></category>
            <dc:creator><![CDATA[Hagen Schendel]]></dc:creator>
            <pubDate>Sat, 26 Feb 2022 05:46:14 GMT</pubDate>
            <atom:updated>2022-03-02T01:39:53.584Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2qiqTQt145AuhzO1BL7yqQ.jpeg" /></figure><p>When I first used the <a href="https://firebase.google.com/docs/functions/schedule-functions">comparatively easy way to set</a> up a schedule-triggered cloud function using Firebase, every firebase deploy resulted in the same annoying error message:</p><p>Error: There was an error deploying functions</p><p>No further information was given, and nothing visible in the Firebase Functions Log View. Still the function was deployed, but not run on schedule. The Google Cloud Console’s <a href="https://console.cloud.google.com/logs">Log Explorer</a> was a bit more helpful. There I found the slightly more specific error message:</p><p>Schedule or time zone is invalid.</p><h4>The Proper Way</h4><p>That led me to revisit the documentation again, and reformulate the correct JavaScript code to set up the scheduled cloud function using a <a href="https://firebase.google.com/docs/reference/functions/function_builder.functionbuilder">FunctionBuilder</a> object:</p><pre>const functions = require(&quot;firebase-functions&quot;);</pre><pre>exports.someFunction = functions<br>    .region(&quot;europe-west1&quot;) // put your region here<br>    .pubsub.schedule(&#39;0 9 * * *&#39;) // scheduling statement<br>    .timeZone(&#39;UTC&#39;) // don&#39;t forget the time zone<br>    .onRun(async (context) =&gt; {<br>    // your cloud function here<br>    console.log(&#39;someFunction was run&#39;);<br>});</pre><p>A bit more explanation about the code:</p><ul><li>Explicitly stating the region is necessary, as the Firebase default GCP region seems to be ignored.</li><li>The scheduling statement can either be in <a href="https://en.wikipedia.org/wiki/Cron">cron syntax</a>, or in the App Engine’s <a href="https://cloud.google.com/appengine/docs/standard/python/config/cronref#schedule_format">cron.yaml syntax</a>. The cron syntax is easier to get right, whereas the cron.yaml syntax is easier to read, but also easier to get wrong. And you will not find a specific error message anywhere! So I recommend you to start with cron.<br>In my example, the function is run at 9:00 UTC every day.</li><li>Also, thetimeZone declaration seems to be required, which makes sense, as it makes the definition unambiguous.</li><li>It is good practice to generate at least one log line per function call to be able to see what the scheduled function has been doing.</li></ul><h4>Batch Jobs</h4><p>If the scheduled function is a batch job, e.g. deleting old data once a day or so, you might want to consider a few more things that can be set using the FunctionBuilder’s <a href="https://firebase.google.com/docs/reference/functions/function_builder.functionbuilder#runwith">runWith</a> method:</p><ul><li>Timeout: The default timeout for a function is 60 seconds, after which its execution is killed, to mitigate the risk of an infinite loop. If your job takes longer, you better set it explicitly.</li><li>Memory: If you need to juggle large data structures in memory, maybe the default of 256 MB is not enough, so you can explicitly require more, which of course raises the cost.</li><li>Retries: If your batch job is likely to fail due to external circumstances, and a retry would help, you can configure <a href="https://firebase.google.com/docs/functions/retries">retry on failure</a>.</li></ul><p>As an example, let’s say the above function needs 120 seconds, and 1 GB of memory, and also should be retried, then we would set it up like this:</p><pre>const functions = require(&quot;firebase-functions&quot;);</pre><pre>exports.someFunction = functions<br>    .region(&quot;europe-west1&quot;)<br>    .runWith({<br>        timeoutSeconds: 120,     // 120s timeout<br>        memory: &quot;1GB&quot;,           // 1GB RAM<br>        failurePolicy: true })   // retry<br>    .pubsub.schedule(&#39;0 9 * * *&#39;) <br>    .timeZone(&#39;UTC&#39;) <br>    .onRun(async (context) =&gt; {<br>    // your cloud function here<br>    console.log(&#39;someFunction was run&#39;);<br>});</pre><p>I hope to spare you to search the error logs with this article. Have fun with Firebase!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e70219cff49c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agile Enterprise Stereotypes]]></title>
            <link>https://medium.com/hackernoon/agile-enterprise-stereotypes-55e9f2d830b1?source=rss-c0ee20032e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/55e9f2d830b1</guid>
            <category><![CDATA[humor]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[corporate-culture]]></category>
            <dc:creator><![CDATA[Hagen Schendel]]></dc:creator>
            <pubDate>Sun, 21 Apr 2019 10:23:29 GMT</pubDate>
            <atom:updated>2019-07-28T14:51:56.698Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vJt80fFch6zNocfS6CEgjA.png" /></figure><h4>SURVEY OF ALL AGILE CREATURES IN THEIR NATURAL HABITAT</h4><h3>Corporate Agile Stereotypes: A Humoristic Taxonomy</h3><h4><em>Hobby Anthropology in the Agile Age</em></h4><p>If you have spent some time in big companies that do “Agile”, you might have noticed that there are quite a few recurrent patterns. People slip into stereotypical roles, as has been true for every organizational fad since the Roman legions have been transformed by Gaius Marius. Let’s try to survey them for “Agile” enterprise organizations!</p><p>Corporate anthropology has become a serious research topic in the last 20 years or so, with good reason. Please note that this article is neither serious, nor scientific. Please note also, that slipping into the stereotypes to me appears to be completely uncorrelated to gender, so I am just alternating the personal pronouns here.</p><h3>The Agile Court Jester</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*4bWzj1YR7WAkudmakHRRCg.png" /></figure><p>The Agile court jester fits into a very important ecological niche that often arises when the CEO has let it be known, that henceforth the company should adopt more of this “Agile” thing. Every director or VP with at least a decent level of cunning knows that it is important to appear “Agile” now. The smarter ones know that faking it only brings you so far. What you need to do is to retain at your court a true believer, someone who preaches “Agile” to everyone within hearing range, generating a lot of activity and buzz that is coincidentally picked up by the CEO. Just make sure this person does not become dangerous by really trying to change things. This is where the Agile court jester comes in handy. He likes to be at the forefront of the revolution (without getting bloody). He also likes the fact, that besides buzz and activity, no tangible results are expected from him.</p><p>Typical quote: <em>“I am too early.”</em></p><p>What can you do? Actually, if the Agile court jester is at least a decent public speaker, he can do a lot to disseminate Agile ideas among the company’s staff. Just make sure he does not spread too much fake Agile.</p><h3>The Ignorant Line Manager</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*VUJ6vi-cv7eB5zc2LCACTg.png" /></figure><p>Agile is neither part of the company’s process handbook, nor part of her bonus agreement. So why take it serious? She is sending out 1:1 appointments that conflict with Sprint rituals. She assigns Scrum team members to “special tasks” without caring about the Sprint. She actively encourages specialization. Her direct reports should sit close to her corner office, who cares about <a href="https://www.martinfowler.com/articles/remote-or-co-located.html">co-location</a>?</p><p>Typical quote: <em>“What is a Sprint? Since when are you guys doing sports?”</em></p><p>What can you do? Conspire to update her personal bonus targets to this:</p><ul><li>Establish a continuous delivery pipeline for your team(s) until the end of the year.</li><li>Features must be released on their own, with at least two releases per business day on average.</li></ul><p>MWAHAHAHAHA</p><h3>The Angry Line Manager</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*HGZLo0AJqirvRaSVAHv1bQ.png" /></figure><p>The angry line manager is really annoyed by this whole “Agile bullshit”. No one is taking responsiblity anymore. The teams are stuck in infinite loops of Retro discussions. Scrum Masters are agitating against middle management. Anarchy is breaking loose. And his boss is buying the Agile snake oil while still making him responsible for the whole mess.</p><p>Typical quote: <em>“Stop bullshitting me!”</em></p><p>What can you do? He just wants to be taken seriously and play with the other kids. Maybe invite him to a round of <a href="https://management30.com/practice/delegation-poker/">delegation poker</a>?</p><h3>The Populist Scrum Master</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*FpRlgqi7i6TRLSRs-71NrQ.png" /></figure><p>Being the Scrum Master in a corporate environment can be a very taxing challenge. On the one hand, lots of organizational impediments (e.g. just four releases per year) have to be overcome. On the other hand, the team members’ mind set has been formed by years of exposure to a corporate hierarchy. But wait. Who said you really have to overcome anything, or change your team’s mind set? This is a corporate environment, you are not measured by results, but by social acceptance! And you can bet that the populist Scrum Master is accepted by her team, thanks to good old populism. The team is unsure how to explain a recent failure? She will find someone to blame. Home office conflicts with Sprint rituals? She will make sure you can opt out of the rituals, instead of making the rituals work for remote participants. Customer support complains about too many bugs? She will shoot the messenger. The Product Owner makes the team feel uncomfortable? She makes sure it’s mutual. She will protect the team from the ambition of others, and also from their own ambition.</p><p>Typical quote: <em>“Should we really release today? How about waiting until Monday?”</em></p><p>What can you do? As always with populism, you have to wait until the collapse. And make sure the populist Scrum Master cannot blame you for that as well. Or just lay back and enjoy the illusion while it lasts.</p><h3>The Clueless Product Owner</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*K9MqlD91XzstpyK1PFyQ7w.png" /></figure><p>He is the personification of the <a href="https://en.wikipedia.org/wiki/Peter_principle">peter principle,</a> having started at the company as a customer support person, a UX guy, or a developer, and then being the only one around willing to work as a Product Owner for the low salary the company is willing to pay. Or, as usually happens, he was simply not able to say no to his boss. Now he has to guide a full-blown cross-functional team poised for action and creativity, has to tame his share of vicious corporate stakeholders, and even needs to develop an understanding of what the customers want. Unfortunately, he is not aware of these challenges, and absolutely incapable of meeting them. He has no drive and no ideas on what to do with the product. He cannot clarify anything, and so is not able to put something meaningful into the backlog. Whenever a stakeholder pushes for something, he forwards it directly to the team. The team thinks he is weak and cannot stick to a plan (what plan?), so they don’t take him seriously. By the time he realizes that there is a political game of rugby going on, with him being the ball, it is too late.</p><p>Typical quote: <em>“I cannot decide that now.”</em></p><p>What can you do? Not much. He is a hopeless case. Maybe push for introducing <a href="https://less.works/">LeSS</a>, so he is not needed anymore, and can happily revert to his old role without responsibility.</p><h3>The Passive-Aggressive Senior Developer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*C_QdK1TfK2GrzyIobzg9cQ.png" /></figure><p>She told anyone who would ask that this would not work. Of course management, as always, overlooked her when making their decision, and did not ask her. She would not tell them, because making proper decisions is their job. And the company could have promoted competent people into management. Such as her. Of course, she did not apply for the team lead position when it was opened. If the boss would have done his job properly, he would have asked her. Because after all that she has done for the company, she would have been the natural choice.</p><p>Being denied her fair chance, the least she can do is to make sure her team treats her with the appropriate level of respect due. The absence of supervision in a self-organizing team gives her oh so many chances to do so. If a new developer joins, she will make sure to be the reviewer of his first big pull request. And boy, will she make that guy suffer. It is important that he learns right from the start, who is in charge here. The Scrum Master has ideas? She will make sure the team opposes them. The status quo always works best for her, especially because you know whom to blame when something goes wrong. The Product Owner has ambitions? She will thwart them out of principle.</p><p>Typical quote: <em>“A good idea. Unfortunately it will not work because…”</em></p><p>What can you do? Try to understand her grudge, and maybe address it. But more important is to make the team realize that there is a wolf in sheep’s clothes among them.</p><h3>The Hipster Developer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*1Y9_WI7LX0fDlotK0xjC7w.png" /></figure><p>He likes to go to meetups, and talk about the new stuff he has tried out recently at work. It pains him to hear about a fancy new JavaScript framework, while not being able to actually ship some code that uses it. Whenever some backward-thinking boss talks about not walking into a <a href="https://devcenter.heroku.com/articles/logplex">cloud</a> <a href="https://cloud.google.com/">vendor</a> <a href="https://azure.microsoft.com/en-us/services/active-directory/">lock-in</a> <a href="https://aws.amazon.com/lambda">trap</a>, he takes it as a personal insult. Every programming language that has been around at the company since more than two years is by definition not cool. Fortunately, in a Scrum team, the majority opinion can be shifted towards a more progressive stance on framework adoption. In the end, everyone wants a modern-looking CV. Which turns out to be useful when the team is finally disbanded due to absolutely failing to meet any business requirements, let alone the customer’s needs (while being lightyears ahead of the company’s technology roadmap).</p><p>Typical quote: <em>“Our frontend framework is completely outdated.”</em></p><p>What can you do? Make sure to praise him when he delivers a user story without changing the architecture. Make sure the whole team gets to decide on every new dependency. And then never forget to ask about the learning effort — that should reign him in.</p><h3>The Scrum Secretary</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*sGJ00RltynaSQaol2pslYQ.png" /></figure><p>You know the team has a Scrum Secretary instead of a Scrum Master by just looking at the Sprint board. Her handwriting is on all tickets. Which she has transcribed meticuously from JIRA. During backlog refinement, she stenotypes every utterance directly into JIRA. She will compile any weekly KPI report requested by anyone, even though no one reads it. As you might have guessed by now, she has been working in a <a href="https://en.wikipedia.org/wiki/Project_management_office">PMO</a> role before. While everybody complains that the company is perverting Agile by handing it down with a process handbook, she is actually quite happy about it.</p><p>Typical quote: <em>“Let’s fill this out!”</em></p><p>What can you do? The Scrum Secretary has her strengths. The team will always have a conference room reserved for their meetings. But still you need to wean the team off her tight processual embrace, so they can start thinking by themselves about how they want to work as a team.</p><h3>The Superfluous Scrum Master</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*Fnr6krEwxJKj_Ols-TNv2Q.png" /></figure><p>He is there. Besides emitting carbon dioxide to the office plant’s delight, he is not contributing much to the team’s productivity. OK, that’s not fair. He is sending out the Outlook invitations. The reason for his reluctance to act is that he does not want impede the team’s self-organization. And maybe he is a bit afraid of being exposed as a Scrum novice. But without acting, you cannot learn a craft, so he is not making any progress.</p><p>Typical quote: <em>“What would you decide?”</em></p><p>What can you do? Explain to him the concept of <a href="https://en.wikipedia.org/wiki/Shuhari">Shuhari</a> applied to Scrum. And strengthen his back so he dares to act.</p><h3>The Ambitious Scrum Master</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*_LIa11eT1plddDrUZjD6-Q.png" /></figure><p>She is a former consultant, and she already helped a lot of teams on their way to top performance. When the consultancy kicked her <a href="https://en.wikipedia.org/wiki/Up_or_out">out and not up</a>, she jumped onto the Agile train. Now she is there to help YOU! As the teams are not as smart as her, they need to listen to her ideas. There are just two things about Scrum she does not like: First, self-organization does not work without smart people like her. Second, in this whole team thing, it is really hard to receive credit, where credit is due. Unfortunately, the consultancy has poisoned her mind so much that she cannot even spell the word “sustainable” anymore.</p><p>Typical quote: <em>“I would recommend…”</em></p><p>What can you do? Modern clinical psychotherapy has ways to induce empathy into former criminals or business consultants.</p><h3>The Project Managing Scrum Master</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*p-mlGJTIDTPEVoCrxt64yQ.png" /></figure><p>He is a victim of the Agile wave. Before it washed over the company, he had eked out a comfortable position as a project manager. Then management switched the company from ITIL to SAFe over night, and everybody tried to find a new stone to hide under. His boss set him up as a new Scrum Master. If there is one thing he learned from his long time at the company, it is loyality. So without questioning his boss’s decision he started to call himself Scrum Master, even though in his ears it does not sound as prestigious as his previous position. Other than that, not much has changed. Most important, his company car is staying the same. Maybe there is a bit of tension within his Scrum team, as everything critical that is spoken within the team somehow reaches the ears of the boss. Maybe Scrum is not really implemented by the book. Maybe the team is neither a team, nor self-organizing. But who would want to be so dogmatic? ITIL was also taken more as a rough guidance (otherwise the company would not exist anymore today).</p><p>Typical quote: <em>“I am here to help.”</em></p><p>What can you do? Run! He is just the symptom of a much bigger malaise.</p><h3>A grain of truth</h3><p>I hope you had at least a few good laughs while reading this article. Maybe you were recognizing a colleague. Maybe even yourself. Now step back, and ask yourself how someone ends up filling out a stereotype. Maybe a few are psychopaths who have found their true calling. But the majority are there because their company culture has led them. Some stereotypes can be explained by <a href="http://www.craiglarman.com/wiki/index.php?title=Larman%27s_Laws_of_Organizational_Behavior">Larman’s tragicomic law</a>s. But everybody deserves at least some career counseling and a training before switching into a new role. And most people new to the Agile software development environment need a bit of personal coaching in the beginning. So if you have the chance, give these stereotypical people a chance!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55e9f2d830b1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/agile-enterprise-stereotypes-55e9f2d830b1">Agile Enterprise Stereotypes</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 reasons for your Scrum team to wait for the Sprint Retrospective]]></title>
            <link>https://medium.com/@hagen.schendel/5-reasons-for-your-scrum-team-to-wait-for-the-sprint-retrospective-6dacceb5d5c6?source=rss-c0ee20032e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/6dacceb5d5c6</guid>
            <category><![CDATA[agile-retrospective]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[self-organization]]></category>
            <category><![CDATA[scrum-master]]></category>
            <dc:creator><![CDATA[Hagen Schendel]]></dc:creator>
            <pubDate>Sat, 29 Dec 2018 09:26:40 GMT</pubDate>
            <atom:updated>2019-06-15T09:56:03.231Z</atom:updated>
            <content:encoded><![CDATA[<p>Your team complains about too many meetings and a useless Sprint Retrospective at the same time? Time to take a stand for the Retro!</p><p>If you had boring, listless Sprint Retrospective meetings while at the same time multiple relevant topics are already being taken care of in special meetings and groups, the problem might be the way the Retro is conducted. But sometimes it is just that there are no good topics left for the Retro. Here are some arguments to help you convince your teammates to bring their topics into the Retro instead of convening the next ad-hoc meeting.</p><h3>#1 Less meetings</h3><p>The easiest argument is that by waiting for the Retro, overall the team will spend less time in meetings.</p><p>You can easily explain this by showing the team an exemplary schedule such as this, where at least four topics look like they should be at least decided upon in the Retro:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/1*9LBz_dQJZ5aV3Ct6TILlrQ.png" /><figcaption>A team that talks too much. The four marked meetings are candidates to be folded into the Retro.</figcaption></figure><p>The decision whether move a topic into the Retro or not could be taken in the Daily Scrum.</p><p>This of course only works if the team prefers working on the Sprint to having lots of meetings. If that is not the case, you already have a relevant Retro topic…</p><p>Another anti-pattern that fits into this line of argument is a boundless Daily Scrum. If it slips into long inspect&amp;adapt discussions regularly, the Retro will suffer.</p><h3>#2 Improvement overload</h3><p>Looking at the exemplary schedule above, you can easily spot another problem: What if out of the four meetings and the Retro there are at least five different improvements to be implemented by the team during the next Sprint? Does that sound realistic? Absolutely not so. The average Scrum team I have encountered, in a good Sprint, manages one visible improvement to their way of work, and maybe a few minor ones. And that is already quite good, if you extrapolate this to a full year.</p><p>Jeff Sutherland and Ken Schwaber in the <a href="https://www.scrumguides.org/scrum-guide.html#events-retro">Scrum Guide</a> call the Retro “a formal opportunity to focus on inspection and adaptation”. Most experienced Scrum Masters I know use this opportunity also to have the team pick the most relevant adaptions, and then get those right. They do this because it increases the likelihood of the team successfully implementing these adaptions. This in turn strengthens the inspect&amp;adapt loop. In the end, every adaption is an experiment, and you need some time to inspect their results.</p><h3>#3 Whole team participation</h3><p>The typical ad-hoc problem meeting is usually not very inclusive, and typically only consists of those people affected by the problem. However, if the problem should really be used to improve the way the team works, the whole team has got to decide. And maybe the discussion has to be broadened away from the narrow perspective on just the one problem.</p><p>And if finally it turns out that a solution is best worked out by just a few team members, at least this is a conscious decision — the team then delegates working out a proposal to these team members. And when they come back, the whole team decides. A self-organizing Scrum team is a grass-roots democracy in such matters, and thus the whole electorate should be present when decisions on big adaptions are made.</p><h3>#4 Take out the drama</h3><p>Setting up a meeting whenever a problem occurs feels very Lean and Agile, like pulling the <a href="https://en.wikipedia.org/wiki/Andon_(manufacturing)">Andon</a> cord to stop the production on a Toyota assembly belt. And sometimes it is really necessary. But very often the situation in a software development team is different to the situation at the car factory. If the problem at hand will not make the whole Sprint pointless, it is maybe not warranted to interrupt the whole team’s precious flow. It is better to wait until the dust has settled, and the problem’s relevance and impact can be assessed in a calm manner in the Retro.</p><p>Just proceeding with an ad-hoc meeting yields a high chance of over-reacting to a one-time issue.</p><p>A good way of tackling such a problem is to first discuss it with another team member (pair programming comes in handy here), and then maybe write down an “impediment card” or something similar for the Retro. Or, if you both see this as absolutely necessary, ring the alarm bell and get all hands on deck for the dramatic ad-hoc meeting. Which could also be a made a bit less dramatic by using something like the <a href="https://luis-goncalves.com/instant-retrospective/">instant retrospective</a> format.</p><h3>#5 Moderation</h3><p>If the issue is a controversial one, such as a technical decision that people are very opinionated about, it is good to use a well-known meeting format, and decision mechanisms known to all participants. It is even better if you have a good moderator, such as maybe your Scrum Master. All this you already should have: your already scheduled Sprint Retrospective!</p><h3>A word of caution</h3><p>A permanent “stream” of small adaptions is a sign for a healthy Scrum team. These are for example a refactoring on the fly, a small improvement to the build pipeline quickly agreed upon in the Daily, or a new test case introduced into the regression test suite. This is a very good thing, and it should not be postponed until the Retro. The Retro is for those adaptions that need to be discussed and decided upon, and where all team members should be heard.</p><p>Besides inspecting known problems in the Retro, it can and should also be used to uncover new topics, that have been festering under the surface. If you collect a lot of known problems encountered during the Sprint, make sure there is still time for this aspect in the Retro!</p><h3>More reasons?</h3><p>There should be even more reasons to reserve the most interesting discussions for the Sprint Retrospective. If you have one, please leave it as a comment! There might be someone out there needing just that argument.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6dacceb5d5c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Should new Scrum teams do estimating?]]></title>
            <link>https://medium.com/@hagen.schendel/start-without-estimating-567c6624e838?source=rss-c0ee20032e42------2</link>
            <guid isPermaLink="false">https://medium.com/p/567c6624e838</guid>
            <category><![CDATA[agile-coaching]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[estimations]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Hagen Schendel]]></dc:creator>
            <pubDate>Mon, 10 Sep 2018 11:36:47 GMT</pubDate>
            <atom:updated>2021-07-07T16:27:43.468Z</atom:updated>
            <content:encoded><![CDATA[<h4>An in-depth look into planning for Scrum beginners</h4><p>It is tempting to start with Planning Poker right away, even when no one really understands what is going on. Planning Poker is what a Scrum team is supposed to do. Right? Well, maybe not.</p><p>In my last project I was coaching a team that was still establishing itself. At the client there were at that moment many of these teams, so among us Agile Coaches we were having quite interesting discussions about how to help a new Scrum team to set up themselves.</p><p>One question pops up for every team. How should the team estimate? We had plenty of answers. The most sophisticated proposal was to use story points for the user stories and then during Sprint Planning 2 estimate hours for the sub-tasks.</p><p>When I heard about this approach I felt obliged to show alternatives. Estimation, if at all necessary, is part of a team’s Sprint planning process, and with good reason not part of the official Scrum framework. It is something each team has to work out on their own, and it is something the team should be able to fine tune freely over time. The mentioned approach is something a mature team has ended up with because they are absolutely not full-stack but have different systems requiring different specialists, so it helps them to make explicit what has to be done with how much expected effort in which system. For new teams, especially those with team members not having been exposed to Scrum before, I personally have come to the conclusion that it is better to start without estimating at all!</p><p><strong>Planning is not just estimating</strong></p><p>To understand why, let us revisit the <a href="https://scrumguides.org/scrum-guide.html#sprint-planning">definition</a> of Scrum’s Sprint planning. One purpose is to answer the question: What can be delivered in the Increment resulting from the upcoming Sprint? For that to happen all backlog items that should become part of that Increment have to be understood and considered to be ready and thereby doable by the team. This is really important! Every attempt to circumvent this is doomed to fail. Be aware that the backlog items are just a mental construct trying to describe approximately the features to be implemented in the team’s code base. Successful teams achieve a good shared understanding of the actual Sprint goal, and are not too philosophical about the definition of the backlog items breaking down that goal.</p><p>So this is what I focus on first when coaching the team in their Sprint planning process. When a team properly understands the backlog items, and when they have negotiated and refined each of those together with the Product Owner, the team probably has set a realistic Sprint goal. And their forecast for the Increment is likely to be quite good.</p><p>The next thing I focus on is splitting the backlog items into manageable chunks, preferably sliced vertically, and as independent as possible. This requires a lot of coaching and exercise. And it takes much time, during 1:1 sessions with the Product Owner, during refinement meetings, and during the Sprint planning meeting. There are multiple reasons why I do this. It decreases the risk of the Increment not being delivered at the end of the Sprint. It gives the team and also the Product Owner more control over the Sprint backlog. It allows for a constant burn-down (a.k.a. flow) of backlog items. My ideal is that one developer on a normal work day is able to implement one backlog item, excluding further effort needed by other teammates, such as code reviews, peer testing etc.</p><p>I even discourage teams from creating sub-tasks in their ticket system, and focus on slicing the user stories instead. In my experience, sub-tasks are usually used as the wrong solution to two different problems. On the one hand they are often used to define horizontal slices for user stories that are simply too big. On the other hand they are sometimes used to create something like a checklist to ensure compliance with the definition of done. This should be avoided, as it discourages the active use of the definition of done for every backlog item. It is also more bureaucratic effort. Please note that when the team is not full-stack, i.e. most user stories need to involve at least two specialists, sub-tasks might be actually useful.</p><p><strong>New teams cannot estimate</strong></p><p>So when coaching new Scrum teams in their planning process I focus on the desired outcome and features for the next Increment, which is the content of the user stories, and on the art of vertical slicing. How does estimation interfere with this? Is estimation not supposed to be the tool that exposes different understandings of a user story during planning poker? And is it not supposed to lead the team to discover user stories that are too big, and need to be sliced?</p><p>My experience during my time spent with Scrum teams has lead me to the conclusion, that this usually does not work as expected, at least not for newly formed teams. But why?</p><p>Attaching story points to a backlog item is initially of no help to a new team, as there are no past velocity statistics to look at when determining what goes into the Sprint backlog. This appears to be a chicken and egg kind of problem. The typical answer is simply to start collecting estimates, and use them in the Sprint planning once the velocity “stabilizes”. However, the team’s throughput, and thereby possibly its velocity stabilizes only when they have mastered setting realistic Sprint goals. Which only happens when they are properly understanding and slicing their backlog items. For the velocity to stabilize even this is not enough. They have to develop ways of estimating user story complexity in a reproducible manner over a long period. To be honest, this taking 6–12 months is not unheard of. And with fluctuation being what it is in our business, you can expect at least one team member to change during that period. Which again impacts the team’s throughput.</p><p>As the team grows in their understanding of their product, and their technology stack, their understanding of complexity changes during that time as well. Altogether, this renders the whole endeavor of estimating right from the start quite pointless in my view. You might think that the chicken and egg problem could be circumvented by estimating time, or something called “ideal days”. Unfortunately, this does not help either. As story points estimate the complexity, the unknown is the time needed for the team to “solve” the complexity. If the team estimates the time directly, for a new team the true complexity remains usually unknown, so the estimated time is not very trustworthy.</p><p>I should also mention that team members go on vacation, take sick leave, or are involved in important operational issues like incidents on the production system. As the expected capacity of the team (e.g. measured in available work days during the Sprint), together with story point estimation, this sometimes leads to dangerous pseudoscience such as a formula for calculating the story point capacity from the number of working days. To me, this smells like Taylorism. And I have never seen it work. The result is that the Sprint planning becomes a discussion about estimation and capacity, between team members defending the capacity formula, and a frustrated product owner trying to talk about an Increment that makes sense.</p><p>A new team tends to change their Definition of Done quite often in the beginning to reflect what they learn about what they really can plan for in their Sprint, often related to testing or release management. This is a very good thing, but again changes the baseline for the velocity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eRByGYAtlm53LEa4nkQbzw.png" /><figcaption>Typical “ping pong” velocity for new Scrum teams</figcaption></figure><p>Also, and this happens quite often, even if the whole team comes to the same estimation of the complexity of a given backlog item, they might still be wrong, because they have not taken the time to properly understand it. Or, as the team is new, they are not yet very outspoken among each other, and unwilling to go into conflict “just because a few story points”.</p><p>If the team estimates, and is held accountable for that, this often creates a mental bias towards the “known” approach, as opposed to the more daring “unknown” and therefore harder to estimate solutions. These “unknown” solutions are usually those that move your product forward, and make the difference, so this is not what you want.</p><p>My last argument against having new Scrum teams estimate is the frequent observation of tactical estimating. In the typical setting where developers are asked for estimates, it is often more convenient to be very cautious, because you know something or someone will interfere. So you add a buffer without telling anyone. For some developers, this has become the normal way of estimating, so they do it almost automatically without bad intentions. Unfortunately, this behavior is very counterproductive in a Scrum team. It actually increases the volatility of the team’s velocity. And as the Product Owner might smell the whiff of defensive estimation, it undermines trust.</p><p><strong>Estimating distracts new teams</strong></p><p>So what typically happens with a new team, often involving an inexperienced Scrum Master, is that the estimation process is implemented without questioning it like a cargo cult. Or it might even be forced onto the team by the organization, because the organization is unused to take any decision about software development without estimating first. Because of the observations mentioned before, the following usually happens:</p><ul><li>Instead of first focusing on the contents of a user story, refining the acceptance criteria, and slicing it vertically, the team starts to think about how to implement it. Why? Because how else should you understand the complexity, given that you are supposed to estimate the complexity during the meeting?</li><li>It is a new team. They do not feel safe in their new business domain, and maybe also not in their technology stack. So they tend to overestimate the complexity. Especially when they have not spent much time actually understanding the user story. This frustrates the Product Owner who becomes unwilling to negotiate about the user stories.</li><li>The actual understanding of the user story only happens at the end of the Sprint planning, or even worse, during implementation. At this point of time, there is no chance anymore to negotiate the acceptance criteria. A typical symptom is a story that cannot be completed during the whole Sprint. Less business value than possible is being delivered.</li><li>Due to the lack of understanding, meeting the Sprint goals is like a gamble, a Sprint either fails spectacularly, or new backlog items have to be pulled already after a few days.</li><li>As a result, the velocity is highly unstable. An inexperienced team might then try to “fix” this with more pseudo-scientific estimation processes, such as a capacity formula. Or they start to “under commit” to be on the safe side, but hide the fact.</li><li>If someone up top looks at the velocity as a proxy for the team’s output, more distraction from the actual work is bound to happen.</li></ul><p>In such a scenario, the premature introduction of an estimation process leads into frustration and break-down of trust between Product Owner and team. There, estimation distracts the team from establishing a constructive culture of understanding, questioning, and refining user stories, in a trustful relationship with their Product Owner. This happens more often than not in my experience. As in such a scenario vertical slicing is usually replaced by sub-tasking during a Sprint planning 2, the team and Product Owner have no chance to learn this valuable skill.</p><p>To sum things up, a team new to Scrum needs to get the Scrum basics right first, and together learn the power of iterative software development. Introducing estimation practices too early will very likely distract them from that.</p><p>Therefore, my advice is to simply NOT do estimation when you start a new Scrum team.</p><p><strong>How to plan without estimates</strong></p><p>But how should the team then decide on their planned Sprint goal and Increment? Make this a discussion about outcome and user needs! Once you have the team members actively involved in sharpening the acceptance criteria, and in slicing, my observation is that during Sprint planning or even before sensible proposals for what the Increment should constitute usually emerge from the team. This works best if the Product Owner is able to set a goal for the outcome of the Sprint. If not, as the Scrum Master, do not hesitate to step in and actively lead a discussion about the Increment!</p><p>There a few things that the Scrum Master should keep in mind here:</p><ul><li>Create an environment where negotiating and slicing backlog items is easy and perceived as normal. JIRA and its overhead seem to be unavoidable in many companies, but you need find ways to make this very quick and easy during refinement and planning meetings.</li><li>Avoid the Sprint commitment pitfall! Forcing a Sprint commitment leads to defensive behavior and blocks a constructive discussion. There is no Sprint commitment in the Scrum guide, with good reason. The Sprint backlog is officially a forecast, and not a commitment! The important part is that good software meeting the user’s needs is being built continuously. The rest is just process, and is usually not worth haggling over.</li><li>The Product Owner is the one setting priorities. If the team prefers to do something else first due to “technical” reasons, maybe they are not really trying to plan for the Product Owner’s vision but for their own.</li></ul><p>Now, what should you do when the Product Owner or their boss wants to know what the team expects to achieve over a period of multiple Sprints? Should we not have a properly estimated backlog just for that? Well, again this requires the people doing these estimates to understand the backlog items. Which usually not even the Product Owner really has for backlog items that are not refined yet. But still, you can avoid estimates even for this. Do a session with the team, or with a few selected members to find sensible Increments for each Sprint in the forecast period. You should not be above the time-honed practice of adding buffer Sprints to cover for the lack of understanding. Long-term forecasting or planning for new Scrum teams is a topic on its own, but do not use your avoidance of initial backlog estimation as an excuse to not come up with long-term forecasts! Otherwise the organization might feel the need to force you to estimate.</p><p>To visualize the progress, in work, as well in the art of vertical slicing, just use the number of backlog items done. Where done ideally means released to the users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uVAfMJjgpLKIEkxLxD4Rtg.png" /><figcaption>Typical Sprint throughput in a new team focussing on small vertical slices</figcaption></figure><p><strong>Maturity helps</strong></p><p>When a team has mastered story understanding, negotiation, and vertical slicing, they might revisit the estimation topic. In my opinion such a team has achieved the understanding that is necessary for this discussion, so even if you are generally skeptical about estimating (as I am), as the team’s Scrum Master or Coach you can be more relaxed about whatever working agreements come out of this. As long as you help them avoid pseudo-scientific delusions. Which is your job anyway.</p><p>What are your experiences with estimating and planning for new Scrum teams? Please leave a comment!</p><p><strong>Notes</strong></p><ul><li>The theoretical underpinnings of why small user stories are beneficial can be found in Donald G. Reinertsen’s seminal book <a href="http://reinertsenassociates.com/books/">“Principles of Product Development Flow”</a>. He is writing more generically about small batch sizes.</li><li>If you need inspiration on how to better slice user stories, this presentation by Neil Killick is a good start: <a href="https://www.slideshare.net/neilkillick/effective-story-slicing">https://www.slideshare.net/neilkillick/effective-story-slicing</a></li><li>The prevailing approach for estimating in Scrum was popularized through Mike Cohn’s book <a href="http://www.mountaingoatsoftware.com/books/agile-estimating-and-planning">Agile estimating and planning</a>. While it is a good read, much pseudoscience has been built on the ideas.</li><li>Planning poker itself is not to blame, it was created to avoid time-wasting, dysfunctional, ego-driven estimation sessions. You might be interested in a <a href="https://wingman-sw.com/slides/Beyond-Planning-Poker-v1r1.key.pdf">presentation by James Grenning</a>, the inventor of planning poker.</li><li>To get a grip on why newly formed teams are usually not outspoken enough among each other, <a href="https://www.tablegroup.com/books/dysfunctions">“The Five Dysfunctions of a Team”</a> by Patrick Lencioni can give some insights.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=567c6624e838" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>