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 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!

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 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.