Elixir Wizards

In Season 15 episode 3, Charles Suggs sits down with Greg Medland, aka “The Elixir Fixer,” to talk about the current state of hiring and the software jobs market in 2026.

 

Greg shares what he’s seeing from both sides of the hiring process as an Elixir-focused recruiter, from shifting company expectations to the growing importance of specialization, communication skills, and real-world product thinking. We discuss how the market has changed since the 2021–2022 hiring boom, why things feel more uncertain today, and how developers are adapting to a slower, more competitive landscape.

 

The conversation also explores how AI is affecting hiring workflows, résumé quality, technical interviews, and even the rise of fraudulent candidates. Greg explains why human relationships and reputation still matter more than ever, especially in smaller ecosystems like Elixir where community connections carry real weight.

 

Along the way, we talk about what junior developers are up against, why senior engineers with domain expertise continue to stand out, and what developers can do to position themselves more effectively in today’s market. Greg shares practical advice for building a sustainable career, developing a clear professional identity, and navigating a rapidly changing industry.

 

Topics discussed in this episode:

The current state of the Elixir job market

Hiring trends and market shifts since 2021–2022

How AI is changing hiring and recruiting workflows

Fraudulent candidates and AI-generated résumés

Domain expertise vs. generalist engineering skills

Product thinking and customer-focused development

What companies are looking for in 2026

Junior developer challenges in the current market

Why senior specialists remain in demand

Networking and relationship-building in tech

Open source contributions and visibility in the Elixir community

Standing out in a crowded hiring environment

Résumé quality and application strategies

The role of personal branding for developers

Remote work trends and geographic hiring patterns

Technical interview expectations and evaluation changes

Startup vs. enterprise hiring differences

Human connection in an increasingly automated industry

Career resilience and long-term positioning

Building a sustainable software engineering career

 

Links mentioned:

Socially Responsible Recruitment https://sr2rec.com/en/

Greg’s LinkedIn https://www.linkedin.com/in/elixirfixer/

Greg's email address: [email protected]

In Season 15 episode 2, Elixir Wizards Sundi Myint and Charles Suggs chat with Micah Cooper to talk about distributed systems, data replication, and what it actually looks like to build these ideas in Elixir.

 

Micah shares his journey from Ruby to Elixir and walks us through Visor, a library he’s building based on the Viewstamps replication algorithm. Inspired by systems like TigerBeetle, Visor explores how you can replicate state across nodes using GenServers, giving you fault tolerance and recovery without relying entirely on traditional database patterns.

 

We talk about the difference between distributed systems and data replication, where things tend to get misunderstood, and what changes when you start thinking about state this way. The conversation also touches on event sourcing, tradeoffs in system design, and how Elixir’s distributed model makes some of these concepts more approachable than you might expect.

 

Along the way, we talk about building for curiosity, experimenting with new ideas, and how projects like this push the ecosystem forward.

 

Topics discussed in this episode:

Building Visor and working with the Viewstamps replication model

Replicating GenServer state across nodes

Distributed systems vs. data replication

Lessons from TigerBeetle and financial system design

Event sourcing challenges and tradeoffs

Rethinking database-first architectures

Snapshotting, recovery, and fault tolerance

The role of Elixir’s distributed model

Experimentation, learning, and building for curiosity

 

Links mentioned:

Micah’s GitHub https://github.com/mrmicahcooper

Micah’s GitLab https://gitlab.com/mrmicahcooper

The Visor repository: https://gitlab.com/mrmicahcooper/visor

Visor Hex Package https://hex.pm/packages/visor

Ruby on Rails https://rubyonrails.org/

Phoenix LiveView Framework https://www.phoenixframework.org/

Zig Programming Language https://ziglang.org/

TigerBeetle https://tigerbeetle.com/

TigerBeetle internal docs https://github.com/tigerbeetle/tigerbeetle/tree/main/docs/internals

The BEAM https://www.erlang-solutions.com/blog/the-beam-erlangs-virtual-machine/

GenServer https://hexdocs.pm/elixir/GenServer.html

Apache Kafka https://github.com/apache/kafka

RabbitMQ https://www.rabbitmq.com/

Redpanda https://www.redpanda.com/

SQL https://www.ibm.com/think/topics/structured-query-language

Kubernetes https://kubernetes.io/

YAML https://yaml.org/

Nomad Workload Orchestrator https://developer.hashicorp.com/nomad

Flutter https://flutter.dev/

Commanded https://hexdocs.pm/commanded/Commanded.html

Go Programming Language https://go.dev/

Clojure Programming Language https://clojure.org/

Nebulex https://hexdocs.pm/nebulex/Nebulex.html

Mnesia https://www.erlang.org/doc/apps/mnesia/mnesia.html

Cachex https://hexdocs.pm/cachex/Cachex.html

libgraph https://hexdocs.pm/libgraph/Graph.html

Horde https://hexdocs.pm/horde/Horde.Registry.html

NocFree split keyboard https://www.nocfree.com/

Micah’s LinkedIn https://www.linkedin.com/in/micah-cooper-4a737560/

In the Elixir Wizards season 15 premiere, host Charles Suggs is joined by Holden Oullette, Senior Security Software Engineer at Netflix and maintainer of Sobelow, to talk about how security is evolving in the Elixir ecosystem.

We discuss how certain features of the Elixir programming language (like functional patterns and server-side rendering) provide natural immunity against some common vulnerabilities, and what that means as the language continues to grow. Holden shares how tools like Sobelow are adapting and how new technologies like LLMs and Elixir's type system may help to strengthen security practices.

We cover supply chain risks, ecosystem-level responsibility and reputation management, and how initiatives like AEGIS are prepping the community for more widespread adoption. We wrap with practical tips for teams to be more security-minded throughout the software development lifecycle without slowing everything down.

Key topics discussed in this episode:

How Elixir’s design influences secure-by-default development

Security tradeoffs between server-side and client-heavy architecture

Supply chain risks and what the ecosystem is doing to prepare

Static analysis with tools like Sobelow and AST-based pattern matching

Where LLMs fit into modern security workflows

The role of Elixir’s upcoming type system in improving tooling

Securing CI/CD pipelines and production environments

Balancing development speed with security requirements

Dependency management and vulnerability monitoring

The AEGIS Initiative and ecosystem-wide security efforts

Links mentioned:

Holden’s GitHub https://github.com/houllette

Elixir Programming Language https://elixir-lang.org/

Security-focused static analysis for the Phoenix Framework https://github.com/nccgroup/sobelow

Code Security for Builders https://semgrep.dev/

Erlang Ecosystems Foundation https://erlef.org/

Phoenix Framework https://www.phoenixframework.org/

WebSockets https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Socket.html

https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API

Open Worldwide Application Security Project https://owasp.org/

https://github.com/elixir-ecto/ecto

Log4j Vulnerability https://www.ncsc.gov.uk/information/log4j-vulnerability-what-everyone-needs-to-know

React2Shell Vulnerability https://www.finra.org/guidance/guidance/cybersecurity-advisory-react2shell

The Heartbleed Bug https://www.heartbleed.com/

Elixir Type System https://hexdocs.pm/elixir/main/gradual-set-theoretic-types.html

Holden Oullette “Securing the Future: A Roadmap to Making Elixir the Safest Language” ElixirConf 2024 https://youtu.be/gpvKxS6sY8Y

Aegis Initiative: Supply Chain Security & Compliance Initiative https://security.erlef.org/aegis/

OIDC Tokens https://openid.net/

Anthropic’s Claude Mythos & Cybersecurity https://red.anthropic.com/2026/mythos-preview/

Igniter Code Generation Framework https://github.com/ash-project/igniter

https://smartlogic.io/podcast/elixir-wizards/s13-e01-igniter-code-generation-zach-daniel/

Secure-by-default open source software https://www.chainguard.dev/

https://www.docker.com/

https://github.com/dependabot

https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-models.html

https://nixos.org/

https://smartlogic.io/podcast/elixir-wizards/s14-e08-nix-for-elixir-apps/

https://fedoraproject.org/

https://kubernetes.io/

https://netflix.github.io/chaosmonkey/

https://netflixtechblog.com/all?topic=chaos-monkey
Special Guest: Holden Oullette.

Today, the Elixir Wizards wrap up Season 14 “Enter the Elixirverse.” Dan, Charles, and Sundi look back at some common themes: Elixir plays well with others, bridges easily to access languages and tools, and remains a powerful technology for data flow, concurrency, and developer experience. We revisit the popular topics of the year, from types and tooling to AI orchestration and reproducible dev environments, and share what we’re excited to explore next.

 

We also invite your questions and takeaways to help shape future seasons and conference conversations. Season 14 doubles as a handy primer for anyone curious about how Elixir integrates across the stack.

 

Key topics discussed in this episode:

 

Lessons from a season of interoperability

Set-theoretic types and what new compiler warnings unlock

AI in practice: LLM orchestration, fallbacks, and real-world use

SDUI and GraphQL patterns for shipping UI across web/iOS/Android

Dataframes in Elixir with Explorer for analytics workflows

Python interoperability (ErlPort, PythonX) and when to reach for it

Reproducible dev environments with Nix and friends

Performance paths: Rustler and Zig for native extensions

Bluetooth & Nerves: Blue Heron and hardware integrations

DevEx upgrades: LiveView, build pipelines, and standard project setup

Observability and ops: Prometheus/Grafana and sensible deployments

Community feedback, conferences, and what’s on deck for next season
 
### Links mentioned in this episode:

Cars.com

S14E06 SDUI at Scale with Elixir https://youtu.be/nloRcgngT_k?si=g4Zd4N1s56Ronrtw

https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html

https://wordpress.com/

https://elixir-lang.org/

S14E01 Zigler: Zig NIFs for Elixir https://youtu.be/hSAvWxh26TU?si=d5_5tVuZbNw0KCfT

https://ziglang.org/

https://hexdocs.pm/zigler/Zig.html

https://github.com/blue-heron/blue_heron

https://github.com/elixir-explorer/explorer

S14E08 Nix for Elixir Apps https://youtu.be/yymUcgy4OAk?si=BRgTlc2VK5bsIhIf

https://nixos.org/

https://nix.dev/

S14E07 Set Theoretic Types in Elixir https://youtu.be/qMmEnXcHxL4?si=Ux2lebiwEp3mc_0e

S14E10 Python in Elixir Apps https://youtu.be/SpVLrrWkRqE?si=ld3oQVXVlWHpo7eV

https://www.python.org/

https://hexdocs.pm/pythonx/

https://github.com/Pyrlang/Pyrlang

https://github.com/erlport/erlport

S14E03 LangChain: LLM Integration for Elixir https://youtu.be/OwFaljL3Ptc?si=A0sDs2dzJ0UoE2PY

https://github.com/brainlid/langchain

S14E04 Nx & Machine Learning in Elixir https://youtu.be/Ju64kAMLlkw?si=zdVnkBTTLHvIZNBm

S14E05 Rustler: Bridging Elixir and Rust https://youtu.be/2RBw7B9OfwE?si=aRVYOyxxW8fTmoRA

https://github.com/rusterlium/rustler

Season 3: Working with Elixir https://youtube.com/playlist?list=PLTDLmInI9YaDbhMRpGuYpboVNbp1Fl9PD&si=hbe7qt4gRUfrMtpj

S14E11 Vibe Coding the LoopedIn Crochet App https://youtu.be/DX0SjmPE92g?si=zCBPjS1huRDIeVeP

Season 5: Adopting Elixir 

YouTubeLaunchisode and Outlaws Takeover with Chris Keathley, Amos King, and Anna Neyzberg

S13E01 Igniter: Elixir Code Generation https://youtu.be/WM9iQlQSF_g?si=e0CAiML2qC2SxmdL

Season 8: Elixir in a Polyglot Environment https://youtube.com/playlist?list=PLTDLmInI9YaAPlvMd-RDp6LWFjI67wOGN&si=YCI7WLA8qozD57iw

!! We Want to Hear Your Thoughts *!!*

Have questions, comments, or topics you'd like us to discuss on the podcast?

Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

In this episode of Elixir Wizards, host Sundi Myint chats with SmartLogic engineers and fellow Wizards Dan Ivovich and Charles Suggs about the practical tooling that surrounds Elixir in a consultancy setting. We dig into how standardized dev environments, sensible scaffolding, and clear observability help teams ship quickly across many client projects without turning every app into a snowflake. Join us for a grounded tour of what’s working for us today (and what we’ve retired), plus how we evaluate new tech (including AI) through a pragmatic, Elixir-first lens.

Key topics discussed in this episode:

Standardizing across projects: why consistent environments matter in consultancy work

Nix (and flakes) for reproducible dev setups and faster onboarding

Igniter to scaffold common patterns (auth, config, workflows) without boilerplate drift

Deployment approaches: OTP releases, runtime config, and Ansible playbooks

Frontend pipeline evolution: from Brunch/Webpack to esbuild + Tailwind

Observability in practice: Prometheus metrics and Grafana dashboards

Handling time-series and sensor data

When Explorer can be the database

Picking the right tool: Elixir where it shines, integrations where it counts

Using AI with intention: code exploration, prototypes, and guardrails for IP/security

Keeping quality high across multiple codebases: tests, telemetry, and sensible conventions

Reducing context-switching costs with shared patterns and playbooks

Links mentioned:

http://smartlogic.io

https://nix.dev/

https://github.com/ash-project/igniter

Elixir Wizards S13E01 Igniter with Zach Daniel https://youtu.be/WM9iQlQSF_g

https://github.com/elixir-explorer/explorer

Elixir Wizards S14E09 Explorer with Chris Grainger https://youtu.be/OqJDsCF0El0

Elixir Wizards S14E08 Nix with Norbert (Nobbz) Melzer https://youtu.be/yymUcgy4OAk

https://jqlang.org/

https://github.com/BurntSushi/ripgrep

https://github.com/resources/articles/devops/ci-cd

https://prometheus.io/

https://capistranorb.com/

https://ansible.com/ 

https://hexdocs.pm/phoenix/releases.html

https://brunch.io/

https://webpack.js.org/loaders/css-loader/

https://tailwindcss.com/

https://sass-lang.com/dart-sass/

https://grafana.com/

https://pragprog.com/titles/passweather/build-a-weather-station-with-elixir-and-nerves/

https://www.datadoghq.com/

https://sqlite.org/

Elixir Wizards S14E06 SDUI at Cars.com with Zack Kayser https://youtu.be/nloRcgngT_k

https://github.com/features/copilot

https://openai.com/codex/

https://www.anthropic.com/claude-code

YouTube Video: Vibe Coding TEDCO's RFP https://youtu.be/i1ncgXZJHZs

Blog: https://smartlogic.io/blog/how-i-used-ai-to-vibe-code-a-website-called-for-in-tedco-rfp/

Blog: https://smartlogic.io/blog/from-vibe-to-viable-turning-ai-built-prototypes-into-market-ready-mvps/

https://www.thriftbooks.com/w/eragon-by-christopher-paolini/246801

https://tidewave.ai/

!! We Want to Hear Your Thoughts *!!*

Have questions, comments, or topics you'd like us to discuss in our season recap episode?

Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9