
From Building Things to Telling Their Stories: My AWS New Voices Journey and the KCD Nigeria 2026 Experience
How five weeks of learning, practice and feedback helped me take a real engineering experience from a technical project to the KCD Nigeria stage.



There is a difference between knowing how to build something and knowing how to communicate why it matters.

As engineers, we spend a considerable amount of time learning technologies, experimenting with tools, debugging systems and building solutions. We document our work, contribute to projects and sometimes share what we have learnt with other people.

But communicating technical knowledge effectively is a different skill.

How do you take a complicated engineering experience and turn it into a story that an audience can follow? How do you explain a technical problem without overwhelming people with implementation details? How do you keep an audience interested while remaining technically accurate? And how do you make sure people leave your presentation with something they can actually apply?

These were some of the questions I had been thinking about, and they were a major reason I was excited to become part of AWS New Voices 2026.

In September 2026, I joined the programme as a member of its third cohort. What followed was an experience that influenced how I approached technical communication, prepared presentations and eventually delivered my talk at Kubernetes Community Days (KCD) Nigeria 2026.

This article reflects on that journey, what I learnt, how I applied it and why I now see technical communication as an important part of engineering.
Why I joined AWS New Voices




My journey in technology has involved much more than writing code or deploying infrastructure.

I am a software and DevOps engineer, an open-source contributor, a community organizer and a mentor. Through these experiences, I have had opportunities to teach, write technical articles, support other engineers and participate in community activities.

As the founder and organiser of Cloud Native Ilorin, a CNCF community group, I also understand how important it is to create opportunities for engineers to learn from one another and share their experiences.

Over time, I became increasingly interested in speaking at technical events. I wanted to become better at presenting my work, explaining engineering decisions and making complex concepts accessible to different audiences.

However, I also recognized that having technical knowledge does not automatically make someone an effective speaker.

A technically correct presentation can still be difficult to follow. A slide can contain all the right information and still fail to communicate the main idea. And a speaker can understand a subject deeply without necessarily knowing how to guide an audience through it.

I wanted to improve that part of my engineering journey.

When I learnt about AWS New Voices, I saw an opportunity to become more intentional about how I communicate technical ideas.

After being selected, we were given the opportunity to choose the cohort that best suited our schedules. I chose Cohort 3, the September cohort, and I was genuinely excited to begin.



Five weeks of learning, practice and participation
One thing I particularly appreciated about AWS New Voices was that it was not simply a programme where participants joined meetings, listened to presentations and left.

The sessions encouraged participation.

I attended all five sessions, and each one gave us opportunities to practise speaking, exchange ideas and learn from other participants.

We had discussions, interactive activities and breakout-room exercises where attendees were encouraged to speak about different topics. These activities made the learning experience more practical because we were not only discussing communication; we were actively practizing it.

Sometimes, the hardest part of public speaking is not understanding what you want to say. It is organizing your thoughts, finding the right words and delivering them clearly when you have an audience listening.

Having opportunities to practize in a learning environment helped me become more conscious of those things.

I also appreciated learning alongside other builders with different technical backgrounds and experiences. Listening to how other participants approached their subjects exposed me to different ways of explaining ideas and communicating technical work.

The experience reinforced an important lesson for me:

Technical communication is not just about transferring information. It is about helping someone understand, remember and do something with that information.
Taking the conversation beyond my immediate technical experience: AI infrastructure engineering
One of the subjects I was particularly excited to discuss during the program was AI infrastructure engineering.

This is an area I have become increasingly interested in as I think about the infrastructure required to build, deploy, operate and scale AI systems.

AI engineering is often discussed in terms of models, prompts, applications and frameworks. However, behind these systems is another important engineering discipline: the infrastructure that makes them possible.

This includes compute infrastructure, GPUs, networking, storage, distributed systems, performance engineering, observability, reliability and the operational challenges associated with running AI workloads.

During one of our breakout-room discussions, I spoke about my interest in getting started with AI infrastructure engineering and encouraged other participants who were interested in the field to explore it as well.

I also had an opportunity to share a short keynote-style presentation as part of our program activities, discussing how people could begin exploring this area.

Rather than presenting AI infrastructure as something that only experienced specialists could understand, I wanted to encourage people to approach it progressively: understand the foundations, explore the systems involved, learn how infrastructure behaves under demanding workloads and build practical knowledge.

I also shared books and learning resources that I considered useful starting points.

Some of the books and resources I had been exploring included:
- SRE for AI Systems ā Pravin Nair
- NVIDIA GPU Infrastructure Fundamentals ā Vivian Aranha
- AI Systems Performance Engineering ā Chris Fregly
- Designing NVIDIA AI Infrastructure ā Vivian Aranha
- AI Engineering ā Chip Huyen
- System Design Pocket Guide

These resources reflected an area I was personally investing time in understanding more deeply.

The exercise reminded me that speaking opportunities do not always have to be limited to subjects we have already mastered. We can also communicate what we are learning, share useful resources, explain our interests and encourage others to explore emerging areas responsibly.

The important thing is to be transparent about what we know, what we are learning and what we are still exploring.
The opportunity to put the learning into practice: KCD Nigeria 2026




While participating in AWS New Voices, another important opportunity was developing.
I had been involved with Kubernetes Community Days Nigeria 2026 from the early stages as a member of the Program Committee.

KCD Nigeria is an important gathering for the Nigerian cloud-native community, bringing together engineers, open-source contributors, technology professionals, community organisers and people interested in the future of cloud-native technologies.

The 2026 event took place on October 24, 2026, at Zone Tech Park, Gbagada, Lagos, under the theme:
Telling the African Cloud Native Story.

I was also among those who submitted a Call for Papers proposal. Having gone through the CFP process and received acceptance, I had the opportunity to become one of the event's speakers.
My accepted talk was titled:

From kubectl apply to GitOps Everything
Extending GitOps beyond Kubernetes to the infrastructure around it.

For me, this was an opportunity to share something I had actually built and encountered during my engineering journey.

It was also the perfect opportunity to put the communication lessons from AWS New Voices into practice.





The engineering experience behind my talk
The starting point of my presentation was a question that I believe many platform and DevOps engineers can relate to:

We have embraced declarative infrastructure management within Kubernetes, but are we applying the same discipline to the infrastructure that supports our applications?

Many teams already manage Kubernetes applications using GitOps tools and version-controlled manifests. Changes are proposed through Git, reviewed, and reconciled by controllers such as Argo CD or Flux.

But what about the DNS records, networking resources, cloud permissions and other infrastructure dependencies?

In some environments, these resources are still changed manually through cloud consoles or through ad-hoc Terraform commands.

That was the gap I wanted to explore.

I built a workflow using Atlantis, Terraform and Bitbucket Cloud to manage AWS Route 53 DNS changes through pull requests.

The idea was straightforward: instead of making a DNS change manually, an engineer modifies the Terraform configuration, pushes a branch and opens a pull request. Atlantis receives the relevant event, executes a Terraform plan and posts the proposed changes back to the pull request.

A reviewer can inspect the plan before an authorised person triggers the apply operation.

The result is a more reviewable and traceable infrastructure change process.

My presentation covered the architecture, the responsibilities of each component, the pull-request lifecycle, the Terraform configuration and the challenges I encountered while integrating the tools.

I was also careful to explain an important distinction: Atlantis is not a continuous reconciliation controller like Argo CD or Flux. It automates Terraform plan and apply workflows in response to pull-request events and commands. The broader idea is to extend version control, review and controlled infrastructure changes beyond Kubernetes manifests.

What made the experience worth sharing?
The implementation was not a perfectly smooth journey.
I encountered several challenges, including:

1. Bitbucket authentication
Repository access and Bitbucket API authentication did not behave as I initially expected.
After Bitbucket's changes to App Passwords, I explored Repository Access Tokens but encountered authentication failures with Atlantis. The eventual solution involved understanding the distinction between Git authentication and API authentication, and configuring the appropriate API user.

2. Terraform state management
The remote state backend was foundational to the workflow. I had to account for the S3 state bucket, state versioning, encryption and DynamoDB locking.

3. IAM permissions
Atlantis needed permissions appropriate to the Terraform operations it was expected to perform. Missing permissions led to access errors that required me to investigate the specific AWS operations involved.

4. Repository and workflow configuration
Atlantis repository configuration and workflow restrictions also required attention. I learnt how server-side configuration influences what a repository can define and execute.

These were not simply obstacles to hide from the audience. They were among the most valuable parts of the experience.

I wanted people to see the engineering process behind the final workflow, not just a polished architecture diagram.

I also published a detailed account of the implementation on AWS Builder Center:

Atlantis + Bitbucket Cloud Integration: A DevOps Journey
Applying what I learnt from AWS New Voices to my KCD presentation



Preparing the KCD Nigeria presentation gave me a practical opportunity to apply the lessons I had been working on during AWS New Voices.

One of the biggest changes in my approach was thinking more deliberately about the audience.

Rather than starting with a list of tools or immediately showing Terraform configuration, I wanted to start with a problem people could recognize.

I opened with the contrast between declarative Kubernetes application delivery and infrastructure changes that still happen through manual intervention.
From there, I built the presentation around a sequence:
- Establish the problem.
- Explain why it matters.
- Introduce the architecture.
- Walk through the actual workflow.
- Show evidence from the implementation.
- Discuss the challenges and how I resolved them.
- Extract practical lessons for other engineering teams.

I also made a conscious effort to use actual project evidence rather than relying entirely on illustrative diagrams.

The presentation included the Atlantis interface, a real pull request from my environment, a simplified configuration excerpt and the authentication problem that initially prevented the integration from working.

I wanted the audience to understand not only what the architecture looked like, but also what it was like to build and troubleshoot it.

Another important decision was to avoid turning the presentation into a product pitch.

Atlantis, Terraform and Bitbucket Cloud were the tools used in my implementation, but the bigger subject was platform engineering and the idea that infrastructure changes deserve the same discipline we already expect from application changes.

This was one of the most valuable things I took away from the learning experience: a technical presentation should not simply demonstrate that the speaker knows a technology. It should help the audience understand a problem and see a practical way of approaching it.
October 24: Taking the stage at KCD Nigeria




Traveling to Lagos for KCD Nigeria 2026 was a memorable experience.

Being part of the Program Committee had already given me a different appreciation of what goes into organizing a technical community event. There are proposals to review, speakers to coordinate, sessions to plan and many details that attendees may never see.

But taking the stage as a speaker was a different experience altogether.

I was excited to share my work, meet other members of the community and contribute to the wider conversation around cloud-native technologies.

Delivering From kubectl apply to GitOps Everything was a particularly meaningful milestone for me.

I was not simply presenting a technology I had read about. I was sharing a real engineering journey: the decisions I made, the things that failed, the problems I investigated and the workflow I eventually put together.

The audience response was incredibly encouraging.

People engaged with the subject, asked questions and showed interest in the implementation. After the event, several people reached out to request the presentation slides and discuss how they could apply similar workflows in their own environments.

Some were already using Bitbucket and wanted to understand how they could introduce Atlantis into their workflows.

Others were interested in learning more about the implementation and the practical challenges involved.

One conversation that particularly stood out was with someone who had reviewed my work and asked whether they could hire me as a consultant to help them implement and navigate the same solution.

That was an unexpected but encouraging development.

It reminded me that when we share our engineering experiences in a way that others can understand, we create opportunities for knowledge exchange, collaboration and even professional engagements.

It also reinforced why I wanted to become a better technical communicator in the first place.
What AWS New Voices changed for me




Looking back at the five weeks, the biggest value of AWS New Voices was becoming more intentional about communication.

Here are some of the lessons I am carrying forward.
1. Start with the audience, not the technology
It is tempting to begin a technical talk by introducing the tools, architecture or implementation.

But the audience first needs to understand why the subject matters.

Starting with a relatable problem creates context and gives people a reason to follow the technical explanation.
2. Structure is just as important as technical depth
A presentation can contain excellent technical information and still be difficult to follow if the ideas are not arranged logically.

The order in which a problem, architecture, implementation and lessons are introduced matters.
A good structure allows the audience to build understanding progressively.
3. Show the engineering journey, including what breaks
I have become increasingly convinced that technical talks should make room for real engineering experiences.
Failures, debugging sessions, unexpected behaviour and lessons learnt are often more useful than presentations that show only the final successful outcome.
People need practical knowledge they can use when they encounter similar challenges.
4. Visuals should support the explanation
Slides are not documentation repositories.
They should help the audience understand what the speaker is explaining. Architecture diagrams, focused screenshots, concise code excerpts and carefully selected evidence can communicate more effectively than crowded slides.
5. Speaking is a skill that improves through practice
The breakout activities and speaking exercises reminded me that communication is something we need to practise deliberately.

It is not enough to prepare a presentation once and assume that the skill will develop automatically.

We need opportunities to speak, receive feedback, reflect and improve.
6. Share what you are learning, not only what you have mastered
My AI infrastructure discussions during the programme reinforced this.

There is value in sharing a developing interest, recommending resources and encouraging other people to explore a field.

We should be honest about our level of experience, but we should not wait until we know everything before contributing to a technical conversation.


Connect with me
- Ā GitHubĀ
If you are exploring Route53, Atlantis, Terraform, Bitbucket Cloud and any other version control or PR-driven infrastructure workflows, I would be happy to connect and exchange ideas.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article