How can a junior developer find an Elixir job?

Currently it is very hard to find a position to work with mainly elixir, even for very skilled people.

From my personal experience, after I have used elixir for about 3 years in production, I struggled to find a elixir job (searched for about 3 months the first time) and then landed at a startup, worked there for a few months and left, the startups are always either a hit or miss, very hard to judge beforehand. After that I tried to find another elixir job for about half a year and ended up giving up and now I write Kotlin on Android.

As a suggestion, I would avoid focusing on a single technology, search for a company that develops in a area that might be interesting for you, and at the size you enjoy, for example big companies are good for beginners as they can invest in your general education as a developer, small companies are great to get your hands dirty and have more of a trial by fire (witch I think is the fastest way to learn practical concepts of development).

To be easier to get hired, try to focus on the technology the position you are applying is seeking, because for example in my country HRs get scared very easily if I start writing in my CV that I designed electronics and worked with elixir, when I apply for any mediocre positions.

Quoting from another thread on the same topic:

Everyone’s path will be different, but ask yourself what you can realistically do to make yourself stand out/be more attractive to an employer.. then follow your gut

@AstonJ , I wanted to add a small note about highest paid language. It is better to see the whole statistics (with percentiles at least) in comparison, which are rarely published. The median or average might be high, but the reason for it might be in shortage of junior jobs and junior developers.

Let give me an constructed fake example (salary digits are just some fake numbers) to showcase this fact:

defmodule BasicStats do
  def basic_data() do
    %{
      some_other_lang: [
        %{grade: "junior", salary: 35},
        %{grade: "junior", salary: 45},
        %{grade: "junior", salary: 40},
        %{grade: "junior", salary: 35},
        %{grade: "middle", salary: 50},
        %{grade: "middle", salary: 60},
        %{grade: "middle", salary: 70},
        %{grade: "middle", salary: 65},
        %{grade: "middle", salary: 65},
        %{grade: "senior", salary: 80},
        %{grade: "senior", salary: 95},
        %{grade: "senior", salary: 95},
        %{grade: "senior", salary: 120},
        %{grade: "senior", salary: 150},
        %{grade: "senior", salary: 160}
      ],
      elixir: [
        %{grade: "junior", salary: 35},
        %{grade: "middle", salary: 65},
        %{grade: "middle", salary: 60},
        %{grade: "middle", salary: 60},
        %{grade: "middle", salary: 60},
        %{grade: "senior", salary: 70},
        %{grade: "senior", salary: 70},
        %{grade: "senior", salary: 85},
        %{grade: "senior", salary: 90},
        %{grade: "senior", salary: 95},
        %{grade: "senior", salary: 95},
        %{grade: "senior", salary: 95},
        %{grade: "senior", salary: 95},
        %{grade: "senior", salary: 100},
        %{grade: "senior", salary: 110}
      ]
    }
  end

  def average(values) do
    salaries = for %{salary: salary} <- values, do: salary
    Enum.sum(salaries) / length(values)
  end

  def run() do
    basic_data = basic_data()
    IO.puts("Elixir average paying: #{basic_data[:elixir] |> average()}")
    IO.puts("some_other_lang average paying: #{basic_data[:some_other_lang] |> average()}")

    IO.puts(
      "Elixir junior average paying: #{basic_data[:elixir] |> filter("junior") |> average()}"
    )

    IO.puts(
      "some_other_lang junior average paying: #{basic_data[:some_other_lang] |> filter("junior") |> average()}"
    )

    IO.puts(
      "Elixir middle average paying: #{basic_data[:elixir] |> filter("middle") |> average()}"
    )

    IO.puts(
      "some_other_lang middle average paying: #{basic_data[:some_other_lang] |> filter("middle") |> average()}"
    )

    IO.puts(
      "Elixir senior average paying: #{basic_data[:elixir] |> filter("senior") |> average()}"
    )

    IO.puts(
      "some_other_lang senior average paying: #{basic_data[:some_other_lang] |> filter("senior") |> average()}"
    )
  end

  defp filter(data, grade) do
    for %{grade: ^grade} = e <- data, do: e
  end
end

BasicStats.run()

As result, what you will get:

Elixir average paying: 79.0
some_other_lang average paying: 77.66666666666667
Elixir junior average paying: 35.0
some_other_lang junior average paying: 38.75
Elixir middle average paying: 61.25
some_other_lang middle average paying: 62.0
Elixir senior average paying: 90.5
some_other_lang senior average paying: 116.66666666666667

The average might be higher by Elixir developers, but this can came just from a fact, that the proportions of junior/middle/senior engineers are different between comparing languages. And it might be to the extreme, that for some language on average junior, middle, senior will be more high-paying in another language and the only reason for higher averages/medians might be the shortage of junior jobs for a language as you see in my constructed example. This is just extreme, constructed example to showcase the fact, that it is possible.

Sadly, statistics rarely going into the details for better understanding of underlying reasons, but I’m personally believe, that Elixir high paying language status is at least partially affected by shortage of junior jobs and-or developers.

I mean you work for 3 people, these damn goofy jobs postings as elixir developer who can write react/angular/typescript and knows all their devops stack.

Not to discourage you but for 7 years in Elixir I have almost never seen a company looking for a junior Elixir dev. It’s generally expected an Elixir dev to already be experienced with other stacks, and that an Elixir dev should pull a lot of weight. And it seems that many companies caught up with that fact so you’re usually gonna find yourself in small teams where everyone must be a heavy hitter (and some of them negotiate salaries down pretty aggressively – avoid these at all costs unless your fridge is empty!).

I’ve been in contact with a few companies that were open to juniors but cynically speaking IMO that was just because they wanted to pay less. If you know your way around Elixir, OTP tools, Ecto, Phoenix and can make APIs, HTML templates and even LiveView then you are no longer a junior and should demand a respectable salary.

And, maybe this is just my bias here but I’d think that the example @liveforeverx presented speaks in favor of my hypothesis: Elixir dev jobs are very well paid mostly because most salaries are given from medium to senior devs.

As someone who has recently switched jobs and also acted as a hiring manager, I disagree. My current position just dropped into my lap, where I was approached directly by the team lead. When hiring, we cut requirements because it was difficult to find someone, so that made it easier from the side of the applicants.
Since the market is kinda small and people are needed, being a developer is great.

I don’t back this statement by 3 interviews, I’ve had more than 15 interviews for elixir positions over the last one and half year.

As the next developer, I lack or at least lacked a big part of soft skills, as I worked until that point in a small company, with a small team, where we would focus on solving hard technical problems, so this dragged me back a lot. Also as someone who lived in Moldova all his life, the way I interact and understand people is somewhat different and is specific to east-europe countries, and this cultural gap was felt the more interviews I was doing.

The biggest problem I saw usually was the fact that recruiters look at specific things:

• you should know all their stack, it is a big nono if you don’t know for example react if they use it, this is how I was declined a few times;
• if you worked at a big and renowned company, you have a better chance of finding a job, as stupid as it sounds people think that big companies handle more efficiently software development;
• companies abuse tasks they give as homework, I have done a few tasks, then realized that this is a waste of time when I received a task to implement a state machine they provided, I used gen_statem and implemented it in 15 minutes with tests, their feedback was that this is too complicated and they expected me to use Genserver and only elixir (even though the never specified this and genserver is also a construct from erlang ).

You feel that the world is at your feet when you succeed, however we all should remember that this line is so thin that you can always slip. I have a friend that works now as a JS developer and receives triple my salary, talking with him, he would give me an answer like you, even though a few years ago he was struggling at a dead-end job, where he would work unpaid overtime.

As a fellow Eastern European (Bulgarian), I hear you and I was in such situations a good number of times.

Though have in mind that changing the way you conduct yourself in interviews truly works. As long as you are NOT in a super rush because you’d be hungry if you don’t get the job next week – then be more casual and just chat with people, ask them why do they need the extra programmers, what kinds of problems are they solving, why is their payment not higher (yes you should outright ask them that!), how are the team dynamics, like is there a lot of back and forth or people can be more independent, are people just allocated tasks or next tasks organically emerge after you fix a bunch of stuff, do they have a lot of standups and if so, why… and many, many others.

Here’s a super corny advice: fill out a document outlining all the things you want in a job. Then also fill out everything you could concede on (i.e. I have no problem being contacted outside work hours, as long as it’s not often or require more than 5-10 minutes to resolve – being open to that is in fact a negotiation leverage). Have that document printed out in front of you when you do interviews. Put it on your keyboard and take a look at it periodically as the conversation progresses.

We the Eastern Europeans get uncomfortable when it comes to negotiations. I am 43 at the moment and finally started overcoming this and the results are very encouraging after I started talking with companies again. Things truly look and feel different.

Don’t be ashamed, don’t be uncomfortable, ask for the things you want, mention what you are willing to concede, be casual and treat the interviews as a friendly chat, and never promise stuff you would hate doing afterwards. Find your own way of doing it. There are rules in business communication (like don’t be an ass and don’t talk in a conflict-y manner i.e. with ultimatums) but 80% of it is your own personality and style – and that too matters as lot. You can do it, dude!

Stay strong and work on rewiring your brain, it will pay you huge dividends!

Thanks for the advice!
In my own understanding I tried to do a lot of pointers you mention, still a lot of room for improvement.

One thing that I think I messed up, that would help me tremendously, is not recording the interviews for myself, so I could reflect on the bad things I did with a clear head. The hardest thing I found is finding the flow of the conversations for some interviews, you just get to a stopper point without being able to fully express correctly what you are looking for or what you can bring to table, definitely a point I have to work on.

Definitely, and it can happen to everyone. It’s not shameful to write a plan for an interview before doing it. I actually started doing that. I am pretty good at improvising and people easily like me in non-work settings but you can’t rely even on that when it comes to interviews. You are going to the interview to clear up e.g. 17 separate things before making a decision? OK BUT WRITE THEM DOWN!