Have a look at this roadmap - https://github.com/kamranahmedse/developer-roadmap
The Ruby on Rails Book is % one of the best introductions to backend available; if you’re going with learning Rails (and it’s a good decision), then stick with Rails until you know it, try not to chop and change between languages/frameworks, it’s really tempting, but learning one thing well works better.
I was a Rails dev for several years - a mental dump of a few things I found useful (sorry, wall of text):
Rails is designed to be monolithic - i.e. you put everything in your Rails app, you don’t build multiple small apps that talk to each other (microservices, which [arguably] Node lends itself to). This tends to make it much easier to build and deploy quite complex apps.
Rails has a very specific file structure - one Rails app looks a lot like any other Rails app, code-wise. This is a massive benefit (can’t be understated), as it makes it very easy to understand new codebases (vs. say JS apps, which are much less restrictive, and codebases generally look utterly different to one another).
Rails is extremely good for banging out fully featured web apps quickly: for individual developers and small teams it’s very useful.
It is restrictive - if you stick with “The Rails Way”, it All Just Works, but if you stray off the path a little, it starts to get a little buit painful. Rails is also very much magic, the way a lot of the moving parts work is not explicit - this is nice in some ways as it hides complexities, annoying in other ways.
Eventually you hit the point with Rails where the restrictions become an annoyance - there are good alternatives built in Ruby. Sinatra is the most common, much more lighweight than Rails and good for small apps - it’s very similar to NodeJS’ Express framework (afaik Sinatra was what Express was based on). I’ve heard very good things about Hanami as well; not much of a community though, so help is harder to find.
To get better at Ruby (and Object Oriented Programming in general), this book is exceptional: http://www.poodr.com/. She just released this book as well, which is supposed to be good - https://www.sandimetz.com/99bottles - if you can’t afford it, there is an option to send the authors a nice postcard in lieu of payment: https://www.sandimetz.com/99bottles/postcard
Things that are important that fit into learning Rails that will be important beyond that:
- Deployment of apps - personally I find this the most boring and painful part. The book uses Heroku, which is fantastic for easy deployment of Rails apps, but there are other solutions, so investigation of other options will serve you well.
- Persistence - i.e. databases. Rails uses ActiveRecord, which abstracts away the need to actually touch the database, but understanding how the DB works is very useful - by default it uses SQLight, but you probably want to practise setting up with either MySQL or PostgreSQL; SQLight is great, but not something you want to use for anything important (ie anywhere it’s important to not drop data).
- Authentication - Rails has terrific libraries which make this extremely easy; you can implement it yourself, but Devise is a fully featured authentication solution. Token-based authentication is important as well - OAuth and Jason Web Tokens (JWT) are things you should probably understand.
- Testing (RSpec is commonly used with Ruby) - loads and loads of resources, and the Rails Book is good regarding it. I find this useful: http://www.betterspecs.org/
- REST (and from that, Hypermedia APIs) - Steve Klabnik (formerly very much involved with Ruby/Rails, now working on the Rust language) has an old post with a useful list of stuff - http://blog.steveklabnik.com/posts/2012-02-27-hypermedia-api-reading-list. Microsoft has quite a good overview as well - https://docs.microsoft.com/en-us/azure/architecture/best-practices/api-design. There are lots of resources on this, and the concept is very simple, and Rails can be used to build apps that are just REST APIs very easily.
- Further from that, and something to keep an eye on, GraphQL is an alternative to REST. There are libraries/integrations for Rails: here is a short tutorial (can’t vouch for usefulness) https://medium.com/@DrawandCode/building-a-graphql-api-in-rails-part-1-a40aaf7e165f. And the GraphQL site has a tutorail for using it with Ruby (again, can’t vouch for it) https://www.howtographql.com/graphql-ruby/0-introduction/
- Caching - v important with Rails, and with many frameworks in other languages. There are different types of caching, so reading up on how they apply to Rails and applying them is instructive - they can make otherwise slow apps very fast. There are lots of resources on Rails caching, and the Rails docs are good on it, so have a dig around. One thing that is very common for [http] page caching is Redis, which very easy to use - https://try.redis.io/
- Continuous Integration is something that’s very easy to set up and is widely used in industry - so, say, when you push to Github/Bitbucket/wherever, all the tests (+ anything else you want to happen) gets run. Sounds quite complex, but it turns out to be very simple, and there are lots of services that do this that all have free tiers if you want to try it out and understand what’s happening - SemaphoreCI is what I use, but there are loads of others. You tell it what Git repo to monitor, and every time you push code up, it does its thing.
- Using the package manger, and writing packages - http://guides.rubygems.org/
Going forward, if you’re confident in Ruby, then there are a few backend languages with different characteristics that invite stepping into. Elixir is a functional language that looks like Ruby, written by a former Ruby/Rails guy. It has an excellent web library called Phoenix that is similar to Rails at first glance. It’s exceptionally good for realtime stuff (for example, WhatsApp uses the language Elixir sits on top of). Crystal is a low-level, typed language that looks almost identical to Ruby and from the little I’ve used it is really nice; it’s useful in that if you need something high-performance (like say, processing images), you can write code in a low-level language that wil perform better than in something like Ruby (speed is not really a primary concern of Ruby). Clojure is a general purpose language like Ruby: I’m only going from what devs I know have said, but they found transitioning from Ruby to Clojure really smooth, and it has several advantages (concurrency is great, it’s a Lisp, it works on the Java VM in theory any Java job could be a Clojure job). [Note that average salaries for Clojure devs are the highest of any language, and it’s used more widely than it might seem, as anywhere that uses Java can use Clojure]