Developing software products is a long and tedious endeavour. That’s not a bad thing. Some of the most monumental artifacts of human ingenuity took decades, even centuries, to build. But unlike the Great Wall of China nor the Sphinx, we don’t have to wait for software to be completed and unveiled in all its glory before we celebrate our small wins.
Achieving the first milestone is a defining moment for a team. It sets the right tempo – it creates a quench for accomplishing more – it generates a surge of positive energy, of which the team will need a lot of down the road.
There is something transcendental when a group of people with diverse capabilities is able to create a single working output from their multiple inputs. It’s precious.
So what can be the first milestones for software product development? When can the team have the first taste of success? What does success look like?
Success can happen in Day 1 and it should just feel great. As one of the greatest philosophers once said:
Well begun is half done
~Aristotle
Software product teams can already succeed during their first day. How hard can it be? Not as much as you think.
While success is subjective, we can all agree that when we achieve a tangible part of a larger whole: like a corner in a ten-thousand piece puzzle, or one square meter area of a garden cleared off from weeds, we feel a sense of fulfillment. It makes us squint and assess what we’ve done so far and urge us to continue the work. We can see it – experience it – admire it. It’s visible and quantifiable. We’ve delivered part of the job and we’re far from done, but it’s satisfying just the same.
Give the team a chance to experience this during their first day and they will be inspired for more.
Here are some achievable milestones that you can encourage your team to accomplish together in Day 1.
Milestone 1: Developer flow with code and collaboration
Developers like being on the flow. Like an artist, we create our best work with the right tools, process and environment. Having this in place allows us to focus continuously more on the product and less on practicalities, once we get started.
✅ Suggested activities:
- Create a repo on Github (or your tool of choice) and configure access policies
- Configure branching policies for development and release of features and future hotfixes
- Agree on a code review culture and Pull Request merging policies
- Configure the test, build and package workflow
- Enable security scanning tools
- Agree and setup the backlog management process
- Agree on team collaboration rituals such as planning, stand-ups and demos
- Write a brief description on the team’s documentation
🏆 Final output: A clear and simple flow for working together and delivering secure and quality code
💡Did you know?
That you can and should use tools for automatically checking vulnerabilities in your code and dependencies?
Checkout these tools:
Milestone 2: Developer Experience (DevEx) on local environment
Once we know how we can collaborate on code, it’s time to decide and configure how to run it on our local machines, hopefully with no, or very little, dependency on remote resources. The ideal setup is that all developers have an identical environment and that we can press a single button on our IDE e.g F5, to install all dependencies to run and debug code. But in most cases, developers use different machine specification and preferences. We also have to keep several environment configuration on our machines, if we’re working on different projects. One way around this is to package all our tool stacks for a specific product into a container such as Docker.
✅ Suggested activities:
- Install and configure your IDE
- Determine and install initial tools, frameworks and libraries e.g Dotnet, Node, Docker
- Determine and install initial infrastructure e.g. runtime host, data storage and messaging
- Determine how to store local environment configuration e.g. .env or appsettings.development.json
- Package all these tool stacks into a single container that devs can share
- Make sure that you can build/compile the code, run tests, debug and step through code locally
🏆 Final output: An identical local environment with all the tech stacks and configuration required for running and debugging code
💡Did you know?
That if your team is using VSCode, you can leverage DevContainers for your local environment?
Checkout Azure Dev Container:
https://microsoft.github.io/code-with-engineering-playbook/developer-experience/devcontainers/
Milestone 3: Securely deploy to a non-production environment
Wouldn’t it be fun to simulate how your product will actually run once it goes live? The quicker your team can deploy to a non-production environment, the sooner they can build their confidence on delivering a successful product.
In many companies though, software developers have challenges in gaining quick access to a working, non-production environment. Some of the most common impediments are not necessarily technical. A well-established governance policy empowers developers to deploy resources, while ensuring that they can only access what they need and that they can limit their cost. The lack of such impedes so many development teams and cause frustrations that turn into despair. To solve this, IT organizations must invest in establishing and managing their internal developer platform and ecosystem that enables teams to be more productive and self-reliant, while ensuring security and sustainability.
✅ Suggested activities:
- Choose a hosting platform e.g. Cloud, On-premise or hybrid
- Choose a compute platform e.g containers, serverless, PaaS or VMs
- Choose a data platform e.g. storage, databases
- Create/request for a service account / service principal that has the permission to a sandbox environment
- Determine how to store confidential configuration such as connection strings and keys e.g. Azure Key Vault, AWS KMS or Hashicorp Vault
- Implement a simple IaC for provisioning the initial infrastructure resources
- Implement a simple pipeline for deploying the code
🏆 Final Output: A running solution on a real environment! Yay!
💡Did you know?
That most cloud providers offer free tiers that you can use, even for production? Explore which free resources you can use for your sandbox on Azure or AWS
Did you also know that your organization could potentially improve your developers’ experience by investing on a developer portal? Explore some of these popular frameworks and applications:
Takeaway:
Software product development teams should always be empowered to carve their own path to success. Accomplishing these early milestones will not only establish the prerequisites for building a solid product, but will also help the team learn more about how they work together. No team is perfect and we can always improve our tools, processes and environments. But it’s important that we celebrate our small wins along the way so we get inspired to go after our bigger goals.