Skip to content
Episode 26 58 minutes

From Code to Community with Daniel Afonso

Key Takeaways from our conversation with Daniel Afonso

Daniel Afonso

Senior Developer Advocate at PagerDuty, SolidJS DX Team Member, egghead Instructor, JNation Conference Organizer

Señors @ Scale host Neciu Dan sits down with Daniel Afonso — Senior Developer Advocate at PagerDuty, SolidJS DX team member, egghead instructor, and organizer of the JNation conference in Coimbra — to explore how a kid who taught himself to navigate the web before he could read became one of the most active voices in the developer community. Daniel shares his origin story, how writing about every hard problem he faced at work became the skill that launched his career, and the one hidden tip every developer should use when joining a new codebase.

🎧 New Señors @ Scale Episode

This week, I spoke with Daniel Afonso, a developer advocate, educator, and community builder who has been involved in just about every corner of the JavaScript and front-end ecosystem. He's a Senior Developer Advocate at PagerDuty, a member of the SolidJS DX team, an egghead instructor, and one of the organizers behind JNation — the developer conference in Coimbra, Portugal, where his career in DevRel effectively began. He also competed nationally in C++ programming before he knew what he wanted to do with software, used experimental React hooks in a job interview before the interviewer had ever seen them, and has Batman and Spider-Man tattooed on his arm and leg.

In this episode, we get into the origin story of a developer who learned to navigate the web by drawing symbols from the screen, how writing about every hard problem he faced became the habit that built his career, and why the first thing you should do when joining a new codebase is look at the tests.

⚙️ Main Takeaways

1. He taught himself to use the internet before he could read

At age four, Daniel figured out how to navigate websites without knowing a single word — by drawing the symbols he saw on screen and mapping them to keyboard keys.

  • The setup: Cartoon Network was on the screen. He wanted to interact with it. Reading wasn't an option yet. So he built his own system.
  • The result: His grandparents and parents still tell the story. The instinct to figure things out independently, without instructions, was there from the beginning.
  • Why it matters: That same pattern — observe, map, experiment, repeat — shows up across everything he's built since.

2. Learning in public: write about every hard problem

Every week, whatever took Daniel a meaningful amount of time to figure out at work became a blog post. Not for an audience — just to practice writing and lock in the learning.

  • The habit: Medium first, then dev.to. No strategy, no target readership. Just documenting friction.
  • The compounding effect: Over time, those posts built a portfolio of writing and thinking that made the jump into developer relations credible.
  • The quote: "Every time I had a challenge in my job, something that would take me a bit to figure out, I would write a blog post on it."

3. Read the tests first when joining a new codebase

This is the most practical tip in the episode, and the one most developers overlook entirely.

  • Why it works: Tests tell you the business logic, the maturity of the team, what's been prioritized, and what's been ignored. They're a compressed map of the codebase.
  • The secondary signal: The quality of the tests tells you what kind of team you've joined — what they care about, how rigorous they are, and what to expect.
  • If there are no tests: That is your first task. Don't wait for someone to assign it.
  • The quote: "If you're joining a new company and you want to learn the thing you're going to be maintaining, look at its tests."

4. Breaking into DevRel: two years of building the skills before landing the role

Daniel didn't stumble into developer relations. He saw it at JNation, understood immediately what it was, and then spent two years methodically building the skills it required.

  • The moment: Attending JNation in Coimbra, watching developer advocates on stage, and having a coworker explain what the job actually was. He connected it instantly to his natural tendency to talk and teach.
  • The work: Writing consistently, starting to speak publicly, building a presence in the community. Two years before the first DevRel role.
  • The insight: DevRel isn't something you fall into — it's something you build toward, and the portfolio you need is made of writing and speaking reps, not job applications.

5. Remote conferences during COVID were an accelerant, not a setback

When the pandemic moved everything online, Daniel used it to speak at conferences he never would have accessed from Portugal.

  • The example: React Philadelphia — a conference he spoke at while still based in Portugal. Pre-pandemic, that wouldn't have happened.
  • The effect: Remote speaking gave him reps at international scale before he had the profile or travel budget to match. Those reps compounded.
  • The lesson: Constraints that look like limitations sometimes remove the barriers that were actually holding you back.

6. Using experimental React hooks in a job interview — before the interviewer had seen them

During his TalkDesk interview, Daniel asked whether the interviewer wanted class components or hooks. The interviewer had never seen hooks used in an interview before. He got the job.

  • The context: This was before hooks were stable. Most engineers were playing it safe with what they knew.
  • The signal: Staying current with the frontier of the ecosystem — not just the mainstream — showed up as a differentiator at exactly the right moment.
  • The quote: "From one Sunday to the other, my life changed completely."

7. "Thriving on Overload" — the book he's read three times

This is Daniel's most re-read book, and in the context of DevRel and staying current across a fast-moving ecosystem, it makes complete sense.

  • What it's about: Managing information overload strategically — how to stay genuinely on top of a wide surface area without burning out.
  • Why it matters for DevRel: Developer advocates live in the middle of enormous information flow. The skill isn't consumption — it's curation and synthesis.
  • The principle: Three reads isn't accident. The ideas are operationally useful and apply differently at different career stages.

8. DevRel = making developers successful, not selling the product

The line between developer advocacy and marketing is thin. Recalibrating that line constantly is a core part of the job.

  • The definition: DevRel is the bridge between a company and its developer community. The core skill is making developers successful with the technology.
  • The tension: The moment it tips toward selling rather than enabling, the community notices — and the trust that makes DevRel valuable evaporates.
  • The reality: Holding that line requires constant judgment and, often, difficult internal conversations.

9. "The Phoenix Project" didn't land until he was living it

Daniel read The Phoenix Project before joining PagerDuty. It only truly clicked once he was inside the world of DevOps and observability.

  • The before: He read it, understood it conceptually, thought it was fine.
  • The after: Working at PagerDuty, inside the incident and reliability world, every story in the book suddenly had a direct parallel. The characters became real.
  • The principle: Some books require the lived experience to unlock. Reading them early isn't wasted — but the second read, in context, is where the value is.

10. National programming competitions built rigor before he cared about rigor

Before Daniel knew he wanted a career in software, he was competing nationally in C++ programming in Portugal. He qualified twice.

  • The effect: The competition circuit forced a level of precision, problem-solving under pressure, and structured thinking that most developers only develop years into their careers.
  • The timing: It happened before he had professional goals or a framework for why it mattered. The rigor came first; the career came later.
  • The pattern: Early, high-pressure environments that push you past your current ceiling often define how you think for decades.

🧠 What I Learned

  • Learning in public doesn't require an audience — it requires a habit. Write about what takes you time. The audience is a side effect.
  • The first thing to do when joining a new codebase is read the tests. They contain the business logic, team maturity, and your first roadmap. No tests means that's your first task.
  • Breaking into DevRel is a two-year project of reps, not a single application. Build writing and speaking before you apply.
  • Remote conferences during COVID removed geographic barriers and gave people international speaking reps they wouldn't have gotten otherwise.
  • Staying current with the frontier of your ecosystem — not just the stable mainstream — creates differentiating moments at exactly the right times.
  • DevRel is about making developers successful. The moment it becomes about selling, the trust that makes it work dissolves.
  • Some books only unlock when you're living the context they describe. A second read after experience is often worth more than the first.
  • Early high-pressure environments — competitions, demanding first jobs — install rigor before you know why you need it.
  • Curiosity without instructions, mapping unfamiliar territory, figuring things out before anyone explains them — that pattern shows up early and compounds.

💬 Favorite Quotes

"Every time I had a challenge in my job, something that would take me a bit to figure out, I would write a blog post on it."

"If you're joining a new company and you want to learn the thing you're going to be maintaining, look at its tests."

"From one Sunday to the other, my life changed completely."

"If there's a good story, I'll enjoy it. It doesn't matter if you're from one family or the other."

🎯 Also in this Episode

  • Growing up in Portugal: Cartoon Network at age four, mapping URLs with hand-drawn symbols
  • The national C++ programming competition circuit in Portugal — qualified twice
  • The Farfetch years: joining a senior team at 21 and building in React before hooks were stable
  • Getting hired at TalkDesk by using experimental React hooks in the interview
  • How he became a JNation organizer — started as an attendee, ended up building the event
  • Faris and "the penicillin dish of incidents" — the colleague who has experienced every type of production incident and what you can learn from them
  • The tricky line between internal developer enablement and external developer advocacy
  • The Batman and Spider-Man comic collection — tattooed on his arm and leg
  • "Death in the Family" as the comic that started everything (Jason Todd / Red Hood)
  • DC vs Marvel, and why the story is what actually matters

Resources

More from Daniel:

Book Recommendations:

🎧 Listen Now

🎧 Spotify
📺 YouTube
🍏 Apple Podcasts

Episode Length: 58 minutes on learning in public, breaking into DevRel, reading tests first, and building a career from genuine curiosity.

If you're thinking about developer relations, wondering how to build a presence in the community, or just looking for one concrete tip to use on Monday morning — read the tests first.

Happy building,
Dan

💡 More Recent Takeaways

Hypermedia at Scale with Carson Gross
Episode 53

Señors @ Scale host Neciu Dan sits down with Carson Gross, creator of HTMX, principal at Big Sky Software, and computer science professor at Montana State University. Carson has been programming for more than 30 years, from HyperCard on a family Mac to Excel macros for an industrial engineering firm, a JVM language called Gosu, a Rails startup, and the 2012 library Intercooler.js that he rewrote without jQuery during COVID and released as HTMX. His argument is that the web was built as a hypermedia system, that links and forms are control logic living inside the document, and that most of what we call REST today fails the one constraint Roy Fielding cared about. He also covers which apps HTMX is wrong for, what changed in HTMX 4 and why 3 was skipped, and why his students now sit pencil and paper exams. It is a conversation about using the browser as the hypermedia client it was built to be.

Performance at Scale with Ryan Townsend
Episode 52

Señors @ Scale host Neciu Dan sits down with Ryan Townsend, Principal Product Manager for Performance at Cloudflare, where he owns real user monitoring and the wider performance measurement remit. Ryan has over 20 years in web technology and a decade as a CTO: he co-founded Shift Commerce, the first enterprise scale headless SaaS, and was CTO of Matalan Direct after the business he built came second in Shopify's Build a Business competition with only three months of trading. We cover why the 'Rails doesn't scale' story was always a myth, the resume driven development he kept finding as a fractional CTO, the personalization script that claimed zero performance impact and cost seconds at P90, and how Shift ran over 99% cache hit ratios by splitting the anonymous page from the basket.

Design Systems at Scale with Szymon Chudy
Episode 51

Señors @ Scale host Neciu Dan sits down with Szymon Chudy, Software Engineer at Netflix on the Hawkins team, which builds the design system behind thousands of internal applications used to produce the shows you watch. Before Netflix, Szymon spent two and a half years at Lokalise, growing from senior to staff frontend engineer and leading frontend direction across teams, and before that he toured Poland as a reggae guitarist while freelancing as a web developer in the off season. From why the source of truth for a design system lives in code, to Hawkins Consumer versus Hawkins Professional, to the UI paved road that changes what freedom and responsibility mean at Netflix, to measuring the team on adoption rate and shipping codemods and agent skills for every breaking change, to what being an informed captain who farms for dissent means in practice, this is the design system conversation for anyone maintaining a platform other engineers have to choose to use.

Agentic Systems at Scale with Vilva Athiban
Episode 50

Señors @ Scale host Neciu Dan sits down with Vilva Athiban, Lead AI Engineer at Omio, one of Europe's leading travel platforms, where he architects and ships agentic AI systems in production. Vilva designed and delivered Omio AI, along with the MCP integrations that connect AI agents to the company's systems. He never set out to switch from JavaScript to AI: in June 2024 Omio picked two people to start an AI team reporting to the CEO and CTO, and he learned on the job, from his first API call to an LLM up to a consumer-facing agent whose backend runs on nothing but MCP. From why a bigger model with medium thinking came out cheaper than the mini, to capping tool calls because LLMs are built for token maxing, to the whale hunting request that showed his team guardrails are subjective, this is a conversation about what production agentic systems look like once the tutorials run out.

📻 Never Miss New Takeaways

Get notified when new episodes drop. Join our community of senior developers learning from real scaling stories.

💬 Share These Takeaways

Share:

Want More Insights Like This?

Subscribe to Señors @ Scale and never miss conversations with senior engineers sharing their scaling stories.