If it was me, then I would go with node.js because it has huge a number of packages,community,support & good dev experience and learning curve is also not that steep, if coupled with express.js, its gonna be efficient and fast in serving web requests, and if we adopt good design patterns and follow best practices, I guess it will be easy to maintain it as well, and for storing resumes, video rec etc.., I would use assest management tools like cloudinary etc.., rather than storing in db, coz Its gonna be much more faster this way.

Nuxt + Fastify + GraphQL + Nginx + Memcache = fast, confortable and a lot of plug-ins. Apache is realy slow :(. Nuxt is great and easy to use. Nginx, Memcache and Fastify it's very efficient. GraphQL require much more from You then REST, but give You flaxibility, order, plugin etc. We tried and don't regret .

Moving from Rails will reduce development velocity (if you want to have easy support and update the app) and will require more skilled (expensive) developers to support it.

Without previous experience (5+ years) do not suggest moving to node.js. That code will easily become hard to learn and support.

You always can implement microservices with Ruby, but this approach should be considered only after Series-A and when you will have more than 5 developers and dedicated SRE/DevOps.

I see it's been some time since this was posted, but I'm glad you are migrating to Next.js 🎉!

Me personally, I would run an Express.js backend so that frontend and backend logics don't feel blurred, especially if you want to attract more developers to your project. Keeping frontend separated from the backend makes for a healthier workspace ecosystem and often confuses people less. Furthermore, implementation is a lot easier and later on as you move from RoR to an Express.js server there won't be too much confusion as to how certain parts mesh together.

Based on the features you're looking at I would consider using websockets (WSS or Socket.IO) for the chat application or rolling that with features from WebRTC, which you would need to support video streaming anyways. For authentication you could look at Auth0 which has some very nice libs for authentication or you could rig up your own stitching individual OAuths (Google, Facebook, etc.) along with a simple User/Pass signup that you manage in your database. For payment I would consider using Stripe, it's very popular in the JS ecosystem right now, has lots of documentation and features, and is also pretty cost-effective.

I know it's been some time since you have posted this and you have already made some decisions, but if you (or anyone else reading this) has any question feel free to let me know :)

Just don't .NET. It was a failed idea from the start. Node and javascript are easier to learn, with much wider adoption, and more active communities.

.NET is an old experiment in using a markup language to separate the UI from the business logic. The idea was that this would allow a small team of hyper-competent engineers to build the tooling and code for a large team of less-skilled front-end developers to leverage. In practice, leveraging that customized UI markup requires understanding and adjusting the underlying code. The result is that any UI change requires a hyper-competent .NET engineer.

However, many larger companies bought into it a long time ago, and now have a hard dependency on old monolithic .NET ecosystems, and they do need .NET developers to maintain them.

So, you can get a well paying .NET job without much difficulty. However, you'll neither like it, nor be doing anything interesting. There's no growth here, only a very long slow death of .NET (that'll probably take another 20 years).

Node and Javascript are sticking around, and still growing.

What I can see, you are confusing yourself, if you studied .Net now it's better to work as .Net developer, and you will find opportunities as fresh. Just search and don't waste your time. After you get more experience in .Net, then you can learn NodeJS if you still need to learn it.

The most relevant part is the central architecture more than the specific backend. For me, it makes sense to go for an event-driven solution. In this case, an event is emitted on every new data, and one or more listeners react to it. In AWS, you can easily get this by storing your data in DynamoDB, which is pretty fast, and have as many lambdas working on the received data (here you can find more details). This way, you keep your worker(s) busy fetching data while others consolidate it. I wouldn't get too crazy on the lambdas, and I'd start with one as there will be only one client by your description. My only concern is how similar the APIs you're consuming are. Depending on that, it may be easier to have different lambdas by target API. My only note on the backend language is that if you want low latency, I'd discard Python and Ruby and choose Go (I know that is not in the list, but given that you're open to learning a new language, you could give it a try). It is easy to learn, has excellent performance, and is the only Lamdba runtime with an X (1.X) in the supported language, making it a great choice.

Hey there 👋,

Daniel from the Prisma team here.

I think your choice of a stack would work well for your final year project.

Some recommendations: - Use PostgreSQL if you need a stable stack. Prisma support for MongoDB is currently in Preview and therefore isn't stable. Moreover, PostgreSQL being a relational database enforces a schema more strictly than MongoDB which is useful given that your data model involves multiple relations. - If your Django backend exposes a REST API, you can also expose it over the GraphQL API by proxying requests from the GraphQL API to the REST API. That way, you have a unified API for all operations. This is typically known as wrapping. - Regarding the GraphQL part, I would consider looking at Nexus and nexus-prisma.

For inspiration, check out the Prisma Examples ​repository which contains many ready-to-run examples.

Here's another fully-fledged example using Prisma, Fastify, GraphQL, and PostgreSQL: https://github.com/2color/fastify-graphql-nexus-prisma

Hi. Maybe you can try use FastAPI instead Django https://fastapi.tiangolo.com It could be faster. The FastAPI documentation is so useful and elegant.

Also you can try split a little more the backend and use an "microservice" architecture. Using Kubernetes to deploy your services.

Try to do it with less - Nodejs + Redis + socket.io, optionally you can always communicate with django, but you can do it all in Nodejs, use pm2 and cluster too. For Redis you can also use Pub/Sub, is a good combination for future scaling.

Comparing them end-to-end, Rails comes the most productive in my opinion. But there are bolder parameters you may consider. i.e. no one switches from Django to Rails to improve productivity and vice versa (probably from Laravel to one of those two).

• The language's productivity also matters, which both Ruby and Python are better for that.

• There is a philosophical difference between #Django and #Rails :

• Django supports the "Explicit over Implicit" idea, making it easier for newcomers to understand what's going on. This idea also has downsides. This allows beginners to start working with Django without even learning Django and best practices and defer learning by using references like Stackoverflow.com, which is not a good idea because you potentially don't know things that you don't know! Also, you may find many different project styles.

• On the other hand, Rails support the "Convention over configuration" and Scaffolding idea. It's easier for a Rails developer to be added to a new project or just review a random Rails project. Everything has a default and also it has some downsides as well. e.g. As a beginner, everything feels like magic in Rails, and you don't understand what is going on and how Rails understand while you didn't "explicitly" say what do you want sometimes.

Conclusion: Rails and Django are more productive and you can build projects on your own quickly (many giant startups launched this way!).

P.S: for learning RoR I suggest the book/video from Michael Hartl.

I picked Django because we use it at work. But honestly, if you don't know any of them, I would look at the jobs around where you live and learn the one that either has the most jobs posted or if you can look at the trends the one that is growing the number of jobs the most.

All three would satisfy your needs and all three are good choices. Dotnet core would also be a good choice, again if there are jobs in your area for said technologies. If you literally don't care about this for employment, learn them all and just do it in alphabetical order :)

Note: I think you are wrong about Node being too immature - there are also MOSTLY standards for everything you want to do on the backend that have not changed for many years.

Rails uses too much magic and sugar. Laravel is something from the previous century. I'd say Django can be well balanced choice. I have extensive experience with all three. So, this advice based on practical projects

I recommend Ruby/Rails. I write the text in question answer form:

Quick prototyping

Yes you can use the prototyping in Rails or not. And this can be realized by adding any of testing framework like Cucumber or RSpec for example. Writing the test you can work on the application prototype without a change real code in production, or even development environment.

Easy to get to production level for backend

Yes it is easy, you are able to use the capistrano gem with its modules, if required, to deploy application to production within a day.

Maintainable and buildable by one person alone

Since the Rails gets on itself the main code part of a data processing, you are able easily to generate the required code with build-in Rails or external gem generators, and to merely maintain the your code, if you would cover it with a test of selected test framework.

Enforces conformity, so others can easily read and contribute to the code, making successfully open sourcing possible

As far as I said you can barely control a contribution to your project with using the test covering frameworks, to keep conformity the project.

Works well with React

You can use React along with any JS NPM module easily using webpacker gem.

Has a mature and fairly stable ecosystem for the basics (auth, storage, db, image handling, backups, change history, etc.

Of course the Rails framework is supported by many three-side gems, which can be found at rubygems, that support the authentication (devise), storage feature (fog), db (pg/mysql/sqlite3), image handling (rmagick), backups (backup), change history (history)

Has an ecosystem that will still be alive in 10 years, responding to changes.

Ruby/Rails with the RubyGem ecosystem is actively envolving and not plan to be collapsed and abandned with of development both Ruby language and Rails framework.

So, you can freely and fearlessly start using the Rails framework as server side base for your project.

DJango after a little practice, with migrations and support to a lot of libraries and modules is very efficient to create small projects.

Edit: Between Laravel, Django or RoR (Ruby on Rails)

If you want to create a reliable video streaming service, you'll probably want to go with a UDP approach. TCP will throw an exception as soon as a packet drops. That being said..... Node.js is ultimately a bad choice. Way too high-level. I've found, when working with UDP, it's much more performant on lower level languages like C, etc. As far as my recommendation, if you want to go with something 'new' and fun, check out GoLang. It's low level, and developed to handle high performance at scale.

That's depend on your experience if you are very well in C# you should start using the Technology that's you know and like it.

So none of these tools may be bad for your implementation of this streaming app. But one thing to consider is what are you trying to achieve. If your application is more front end facing with streaming to a backend service C# may be your better implementation path just due to its greater overall versatility in terms of options for mobile, backend development, front end development, service development, etc... However if your focused purely on the streaming aspects and utilizing Amazon or Azure services in conjunction with the language of choice, Python, Node.Js, Django or other technologies may offer a faster option to success. Another thing to consider is many of the streaming platforms today utilize services from cloud vendors to achieve their success more than simply the ingenuity on the part of their internal staff's programming skills. Traditional programming languages like Java, C++, C# are used less these days. Today most teams are piggybacking off these services where its possible to give your application the greatest ability to compete with the big boys. - Your Friendly Neighborhood Tech Manager

You could apparently go for both Node or Django but I would recommend choosing Node as you're building a video streaming app and the biggest video streaming service Netflix used Node in the production.

Take a look at FastAPI if you are going to choose Python

My question for you is: "Which one are you familiar with?" Following your needs, both could do it, but think about it. Now talking about Node.js, in my opinion, if you use JavaScript, there are lots of packages to support your entire project, including native ones for testing TDD and others for BDD. Also the best support on AWS (Amazon Web Services) and GCP (Google Cloud Platform).

I don't have the Scala experience to compare the two, but I can say that Ruby is a wonderful language. For procedural programming where you don't need a lot of concurrent execution threads, it's superior to Node.JS in my opinion. All of the concepts from Typescript have equivalent syntax in Ruby, but there are fewer symbols (e.g. () => { ... }); ) and more keywords (eg 'do ... end'). It's a very flexible language and allows for a lot of different approaches to how it's written, so coding standards and careful organization is important. In the long run, however, you'll find it quicker to debug than Node.JS and just as powerful.

If you are comfortable with TypeScript, why not evolve to a C# ecosystem? Asp.Net Core + Entity Framework is a mature and well supported technology. As far as I can see in the enterprise market, the most adopted choice is still Java. So, maybe you may have a look to SpringBoot - and ultimately Quarkus.

If software performance is your top priority, then Scala/Play is probably best. If developer productivity is your top priority, then Ruby on Rails is the best choice in my opinion.

The Rails framework is batteries-included. The framework takes care of many things by default so that you don't have to. Logging, security, etc. It's also well-integrated; for example, controllers understand models out of the box. I had a better experience with RoR than with Play.

On the other hand, Scala and the JVM are more performant in general, so they can scale to serve more requests per second on the same hardware.

If you're considering serverless functions, then Scala is probably a better choice because it would be faster to load, giving you better economics.

This is advice regardless of your background and requirements. The Play framework has a terrible and complicated design, don't risk it. I even suggest Spring and Kotlin over it! You can use Scala for small services and Data Engineering stuff and benefit optimizations and threading of JVM. RoR, on the other hand, has a huge development speed, which I believe is a big advantage cause you can handle performance bottlenecks later. Also, Scala has another downside, which is featureful in terms of OO and FP paradigms, which makes anyone write code freely with any personal style and makes it a problem in a team, Hence a coding style has to be defined if there would be Scala development team.