← Blog

Is Conference Speaking Worth It? Sometimes One Message Answers That.

Conference speaking takes preparation, travel, and sometimes a little self-doubt. After a recent talk at Atlanta Developers' Conference, one attendee's feedback was a reminder that the real value is what people take back to work and put into practice.

· Blaize Stewart · #conference-speaking #developer-community #software-engineering #ai-assisted-development #architecture-decision-records #professional-development #mentoring

Sometimes you wonder if it's worth it.

I do a lot of conference speaking. It's something I enjoy, and I believe in sharing what I've learned, but there is quite a bit more to it than the hour you spend standing in front of an audience. There is the time spent developing an idea, turning it into a talk, building demos, rehearsing, revising, traveling, and trying to make sure that the material is worth somebody else's time. Sometimes the session goes exactly as you planned. Sometimes it doesn't.

And after doing enough of it, you inevitably ask yourself a question: Is all this effort actually making a difference?

A recent message helped answer that question.

A year of conversations

Looking back over my speaking calendar, 2026 has been a busy year. In May, I was at the Software Design and Development Conference in London. August included the Secure Carolinas Conference in Greenville, South Carolina, and September brought a virtual session for Conf42 AI Agents. In October, I spoke at Atlanta Developers' Conference and then attended Microsoft AI Tour in Philadelphia. More recently, November included the AI Friendly Summit in Charlotte.

Those are different audiences and different settings. Some people are writing software every day; others are thinking about architecture, security, cloud platforms, or how AI changes their organizations. The challenge is to meet people where they are and give them something they can use. A technically interesting presentation isn't necessarily a useful one. Neither is a polished demonstration that leaves everyone impressed but unsure what to do when they return to work.

That's a distinction I've become more conscious of over time. I don't want people to leave thinking only that a technology is impressive or that I delivered a good presentation. I want them to leave with an idea, a method, or a way of approaching a problem that they can actually put into practice.

One hour in Atlanta

On October 17, I presented Vibe Coding for Pro Developers: From Hype to Full Lifecycle Engineering at Atlanta Developers' Conference.

The premise was fairly straightforward. AI tools have made it possible to generate software at a remarkable pace. But generating code is not the same thing as engineering a software system. The difficult parts of the work haven't disappeared: understanding requirements, making architectural decisions, handling edge cases, testing behavior, documenting intent, and making sure the result is secure and maintainable.

In fact, the ability to produce code faster can make those disciplines more important. You can now create problems at a much greater speed if you skip the work that helps you recognize them.

The workflow I talk about isn't a collection of brand-new ideas. Much of it comes from practices that software engineers have refined over decades. Architecture decision records (ADRs) capture the important decisions and the tradeoffs behind them, instead of leaving future developers to guess. Tests help establish whether the software does what it is supposed to do and continues doing it after changes. Documentation makes the design understandable to the next person who works on it. Security and hardening passes force a separate examination of assumptions, unsafe behavior, failure conditions, and things that might otherwise be overlooked.

I also like separating these activities into deliberate passes rather than asking for everything at once. First clarify the problem. Work through the architecture. Implement a piece of the solution. Test it. Review the documentation. Examine it for security and reliability issues. Then iterate. AI can help accelerate many of these steps, but it doesn't eliminate the need for judgment or accountability.

The point isn't to replace engineering discipline with AI. It's to use AI to make that discipline easier and faster to apply. I've found that combining the two works much better than simply asking a coding assistant to write an application and hoping for the best.

A few weeks after that session, Christopher Rowe shared this feedback:

"I just have to say, attending your 1 hour talk was one of the best quick wins in my career. People at work think I'm a superhero at the pace I'm delivering quality code. The ADRs, tests, documentation, and hardening passes are an incredible combo!"

That message meant a great deal to me.

The part that matters happens after the talk

What stood out wasn't simply that Christopher enjoyed the session. He took the ideas back to work, changed how he approached his projects, and found that the combination helped him deliver quality software more quickly. He had a tangible outcome from something he learned in an hour.

That's a much better measure of a successful talk than applause, attendance, or the number of people who come up afterward to say it was interesting.

Of course, those things matter too. I appreciate a good conversation after a session. It's useful to hear which examples resonated, which parts were confusing, and what other people are experiencing in their own projects. Sometimes that feedback improves the talk itself. But the result I hope for is something that happens afterward, when someone is back at their desk facing a real problem.

And it doesn't have to be a dramatic transformation. Maybe somebody adopts ADRs for the first time. Maybe they start treating security review as a normal part of development instead of a final checkbox. Maybe they make a small adjustment to their workflow, avoid a costly mistake, or find a better way to explain an architectural decision to their team.

Small improvements compound. A better process can affect not just one piece of code, but everything that person builds afterward. They may share it with colleagues, who in turn improve their own work. You rarely get to see that chain of events from a conference stage.

Not every talk is a great talk

I also don't want to romanticize conference speaking. Some talks go better than others, and I've certainly delivered sessions where I walked away knowing I could have done a better job.

Sometimes the demo doesn't cooperate. Sometimes I try to cover too much, or the material doesn't land the way I expected. Sometimes the audience is looking for something different from what I prepared. A topic that connects wonderfully at one event can be the wrong fit at another.

That can be frustrating, particularly after investing a lot of time and energy in preparing. Speaking requires you to put your work and your ideas in front of other people, and you don't always get it right. That's part of the process. Like writing software, it gets better when you're willing to hear criticism, learn from what didn't work, and change your approach the next time.

There is also a real personal cost. Travel means time away from home. Preparation competes with professional responsibilities and everything else going on in life. Even when you enjoy speaking, there are moments when the effort feels disproportionate to the result.

And then you receive a message like Christopher's.

Why I keep doing it

I've spent a long time working in technology. I've made mistakes, rebuilt things that should have been designed differently, watched promising ideas fail, and learned practices that made the next project better. Some of those lessons came from my own experience. Many came from other people who were willing to share what they knew.

Conference speaking is one way of passing that along.

It's not really about getting on a stage. It's about making the knowledge transferable. If I can explain a mistake well enough that somebody else avoids it, or demonstrate a method clearly enough that somebody puts it to work, then the time spent preparing and traveling has produced something useful beyond the presentation itself.

Christopher's comment was a reminder of something easy to lose sight of: you don't always know what effect you're having. The most meaningful results may happen weeks or months after you've packed up the laptop, left the conference center, and moved on to the next thing.

I'm grateful he took the time to tell me. And I'm grateful to everyone who has offered feedback over the years, whether it was praise, a thoughtful question, or a suggestion for how I could do better.

At the end of the day, I want to make a difference. If something I share helps somebody write better software, become more effective at their job, or move forward in their career, that's a pretty good return on the investment.

Knowing that, even in some small way, you're making a difference in somebody's career or life makes the preparation, the travel, and even the occasional bad talk worth it.