You have a goal, you know what it means, and what it implies.
You also know what’s blocking your progress.
It’s time to iterate!
Iterating Against the Blockers
Ask yourself:
- What’s the first step?
- What if all I needed was a tool?
- How will I know if it’s working?
These three primary questions will help you chip away at the Blockers.
You want progress, not victory. When you keep iterating away at the Blockers, eventually achieving your goals becomes easy.
Besides the questions, the main constraint to keep in mind is that each iteration needs to leave the system in a state where you can walk away from the project.
Unused functionality? Totally fine.
Refactored code with no new usage? Great!
Tools that work but don’t do anything useful? One day.
Nothing that requires keeping two pieces of code in sync.
Nothing that would prevent other developers from evolving existing code.
Whatever you do, it must go into the system with each iteration.
Example: Continuing from the Async Processing Blockers
I want to make my API asynchronous so that client size doesn’t impact the API’s responsiveness. But, I can’t make the API asynchronous because:
- I don’t have a system to queue the requests.
- I don’t have a system to process the requests off of a queue.
- I don’t have a way to make the processing visible to the client.
Attempting to do all of this work in one giant step is a recipe for a project that gets delivered 6 months to a year late.
I’m going to hand wave and declare that we are using SQS, AWS’s native queuing system. This makes setting up the queue trivial and reliable.
I don’t have a system to queue the requests.
What’s the first step?
Write a data model and serializer. What am I even going to write onto this queue?
What if all I needed was a tool?
Instead of worrying about a system, create a command line tool in your existing codebase to push data to SQS. It won’t be reliable, it won’t have logging, and it won’t have vizability.
But you’re the only one using it, so that’s fine.
How will I know it’s working?
Manually! AWS has great observability. You don’t need to do anything.
Combining your first step, a data model, your tool and AWS observability you’ll be able to push data onto a queue and view what got sent.
The data model will be wrong and the tool will not be production ready!
That’s ok because no existing functionality is blocked or broken. Getting interrupted doesn’t create risk, which means you can work even if you only have a little time.
I don’t have a system to process the requests off of a queue.
What’s the first step?
Write a data model and deserializer. What data do I need to be on the queue in order to recreate the event I need to process?
What if all I needed was a tool?
Create a tool to pull the message off the queue and deserialize. Send the result to a data validator. (You’re accepting customer requests from an API, you’d better have a data validator)
How will I know it’s working?
Manually! AWS has great observability. You don’t need to do anything.
Combining the three gets the ability to manually pull data off the queue, deserialize and validate.
You can do this before, after or during your work to get the data onto a queue. It’s not production ready, but it also doesn’t create risk.
I don’t have a way to make the processing visible to the client.
What’s the first step?
What does visibility look like to the client? Where does the data go in your UI? What would you want to know?
What if all I needed was a tool?
Make an endpoint that calls AWS and returns the data you think you need.
How will I know it’s working?
Manually! Compare what your endpoint tells you with what AWS tells you. Don’t start until you have tools for adding and removing events from the queue.
Combining the three gets you an endpoint that tells you about the queue.
The endpoint should be safe to deploy to production. The queue is always empty.
Conclusion
Iterating allows you to chip away at your blockers until there’s nothing stopping you.
Apply the three questions:
- What’s the first step?
- What if all I needed was a tool?
- How will I know if it’s working?
Always keep the system in a state where you can walk away from the project.
Keep iterating against your blockers, and you’ll be amazed at how soon you’ll achieve your goals!