Alternatives to Hasura

Hi Otensia! I'd definitely recommend using the skills you've already got and building with JavaScript is a smart way to go these days. Most platform services have JavaScript/Node SDKs or NPM packages, many serverless platforms support Node in case you need to write any backend logic, and JavaScript is incredibly popular - meaning it will be easy to hire for, should you ever need to.

My advice would be "don't reinvent the wheel". If you already have a skill set that will work well to solve the problem at hand, and you don't need it for any other projects, don't spend the time jumping into a new language. If you're looking for an excuse to learn something new, it would be better to invest that time in learning a new platform/tool that compliments your knowledge of JavaScript. For this project, I might recommend using Netlify, Vercel, or Google Firebase to quickly and easily deploy your web app. If you need to add user authentication, there are great examples out there for Firebase Authentication, Auth0, or even Magic (a newcomer on the Auth scene, but very user friendly). All of these services work very well with a JavaScript-based application.

This is my stack in Application & Data

JavaScript PHP HTML5 jQuery Redis Amazon EC2 Ubuntu Sass Vue.js Firebase Laravel Lumen Amazon RDS GraphQL MariaDB

My Utilities Tools

Google Analytics Postman Elasticsearch

My Devops Tools

Git GitHub GitLab npm Visual Studio Code Kibana Sentry BrowserStack

My Business Tools

Slack

StackShare Feed is built entirely with React, Glamorous, and Apollo. One of our objectives with the public launch of the Feed was to enable a Server-side rendered (SSR) experience for our organic search traffic. When you visit the StackShare Feed, and you aren't logged in, you are delivered the Trending feed experience. We use an in-house Node.js rendering microservice to generate this HTML. This microservice needs to run and serve requests independent of our Rails web app. Up until recently, we had a mono-repo with our Rails and React code living happily together and all served from the same web process. In order to deploy our SSR app into a Heroku environment, we needed to split out our front-end application into a separate repo in GitHub. The driving factor in this decision was mostly due to limitations imposed by Heroku specifically with how processes can't communicate with each other. A new SSR app was created in Heroku and linked directly to the frontend repo so it stays in-sync with changes.

Related to this, we need a way to "deploy" our frontend changes to various server environments without building & releasing the entire Ruby application. We built a hybrid Amazon S3 Amazon CloudFront solution to host our Webpack bundles. A new CircleCI script builds the bundles and uploads them to S3. The final step in our rollout is to update some keys in Redis so our Rails app knows which bundles to serve. The result of these efforts were significant. Our frontend team now moves independently of our backend team, our build & release process takes only a few minutes, we are now using an edge CDN to serve JS assets, and we have pre-rendered React pages!

#StackDecisionsLaunch #SSR #Microservices #FrontEndRepoSplit

Our whole DevOps stack consists of the following tools:

• GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
• Respectively Git as revision control system
• SourceTree as Git GUI
• Visual Studio Code as IDE
• CircleCI for continuous integration (automatize development process)
• Prettier / TSLint / ESLint as code linter
• SonarQube as quality gate
• Docker as container management (incl. Docker Compose for multi-container application management)
• VirtualBox for operating system simulation tests
• Kubernetes as cluster management for docker containers
• Heroku for deploying in test environments
• nginx as web server (preferably used as facade server in production environment)
• SSLMate (using OpenSSL) for certificate management
• Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
• PostgreSQL as preferred database system
• Redis as preferred in-memory database/store (great for caching)

The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

• Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
• Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
• Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
• Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
• Scalability: All-in-one framework for distributed systems.
• Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.

React Native NativeBase redux-saga Apollo GraphQL Node.js PostGraphile PostgreSQL PubNub . @PLAID Dwolla.js . Zube GitHub Yarn npm AWS Elastic Beanstalk

I just finished a web app meant for a business that offers training programs for certain professional courses. I chose this stack to test out my skills in graphql and react. I used Node.js , GraphQL , MySQL for the #Backend utilizing Prisma as a database interface for MySQL to provide CRUD APIs and graphql-yoga as a server. For the #frontend I chose React, styled-components for styling, Next.js for routing and SSR and Apollo for data management. I really liked the outcome and I will definitely use this stack in future projects.

In my last side project, I built a web posting application that has similar features as Facebook and hosted on Heroku. The user can register an account, create posts, upload images and share with others. I took an advantage of graphql-subscriptions to handle realtime notifications in the comments section. Currently, I'm at the last stage of styling and building layouts.

For the #Backend I used graphql-yoga, Prisma, GraphQL with PostgreSQL database. For the #FrontEnd: React, styled-components with Apollo. The app is hosted on Heroku.

When I joined NYT there was already broad dissatisfaction with the LAMP (Linux Apache HTTP Server MySQL PHP) Stack and the front end framework, in particular. So, I wasn't passing judgment on it. I mean, LAMP's fine, you can do good work in LAMP. It's a little dated at this point, but it's not ... I didn't want to rip it out for its own sake, but everyone else was like, "We don't like this, it's really inflexible." And I remember from being outside the company when that was called MIT FIVE when it had launched. And been observing it from the outside, and I was like, you guys took so long to do that and you did it so carefully, and yet you're not happy with your decisions. Why is that? That was more the impetus. If we're going to do this again, how are we going to do it in a way that we're gonna get a better result?

So we're moving quickly away from LAMP, I would say. So, right now, the new front end is React based and using Apollo. And we've been in a long, protracted, gradual rollout of the core experiences.

React is now talking to GraphQL as a primary API. There's a Node.js back end, to the front end, which is mainly for server-side rendering, as well.

Behind there, the main repository for the GraphQL server is a big table repository, that we call Bodega because it's a convenience store. And that reads off of a Kafka pipeline.

At Airbnb we use GraphQL Unions for a "Backend-Driven UI." We have built a system where a very dynamic page is constructed based on a query that will return an array of some set of possible “sections.” These sections are responsive and define the UI completely.

The central file that manages this would be a generated file. Since the list of possible sections is quite large (~50 sections today for Search), it also presumes we have a sane mechanism for lazy-loading components with server rendering, which is a topic for another post. Suffice it to say, we do not need to package all possible sections in a massive bundle to account for everything up front.

Each section component defines its own query fragment, colocated with the section’s component code. This is the general idea of Backend-Driven UI at Airbnb. It’s used in a number of places, including Search, Trip Planner, Host tools, and various landing pages. We use this as our starting point, and then in the demo show how to (1) make and update to an existing section, and (2) add a new section.

While building your product, you want to be able to explore your schema, discovering field names and testing out potential queries on live development data. We achieve that today with GraphQL Playground, the work of our friends at #Prisma. The tools come standard with Apollo Server.

#BackendDrivenUI

I just finished the very first version of my new hobby project: #MovieGeeks. It is a minimalist online movie catalog for you to save the movies you want to see and for rating the movies you already saw. This is just the beginning as I am planning to add more features on the lines of sharing and discovery

For the #BackEnd I decided to use Node.js , GraphQL and MongoDB:

1. Node.js has a huge community so it will always be a safe choice in terms of libraries and finding solutions to problems you may have

2. GraphQL because I needed to improve my skills with it and because I was never comfortable with the usual REST approach. I believe GraphQL is a better option as it feels more natural to write apis, it improves the development velocity, by definition it fixes the over-fetching and under-fetching problem that is so common on REST apis, and on top of that, the community is getting bigger and bigger.

3. MongoDB was my choice for the database as I already have a lot of experience working on it and because, despite of some bad reputation it has acquired in the last months, I still believe it is a powerful database for at least a very long list of use cases such as the one I needed for my website

When I joined NYT there was already broad dissatisfaction with the LAMP (Linux Apache HTTP Server MySQL PHP) Stack and the front end framework, in particular. So, I wasn't passing judgment on it. I mean, LAMP's fine, you can do good work in LAMP. It's a little dated at this point, but it's not ... I didn't want to rip it out for its own sake, but everyone else was like, "We don't like this, it's really inflexible." And I remember from being outside the company when that was called MIT FIVE when it had launched. And been observing it from the outside, and I was like, you guys took so long to do that and you did it so carefully, and yet you're not happy with your decisions. Why is that? That was more the impetus. If we're going to do this again, how are we going to do it in a way that we're gonna get a better result?

So we're moving quickly away from LAMP, I would say. So, right now, the new front end is React based and using Apollo. And we've been in a long, protracted, gradual rollout of the core experiences.

React is now talking to GraphQL as a primary API. There's a Node.js back end, to the front end, which is mainly for server-side rendering, as well.

Behind there, the main repository for the GraphQL server is a big table repository, that we call Bodega because it's a convenience store. And that reads off of a Kafka pipeline.

Hi Stackers, We are planning to build a product information portal that also provides useful articles and blogs. Application Frontend is going to be built on Next.js with Authentication and Product Database helped by Firebase. But for the Blog / Article we are debating between WordPress/GraphQL plug-in or Strapi.

Please share your thoughts.

First of all, thank you for reaching out and asking the community a question like this, because I think there are a lot of people in this boat.

TLDR; The short of it is - if you are interested in building other sites further down the road, then you would be wise put the work in and build the booking site yourself. It will take time, so you will definitely need to think about long term implications. However, if you are not really interested in building other sites, or you have other really pressing concerns that need your time, it would be best to engage the original web developers to see if they can update the site which would free up your time. The flip side is they might say the whole site needs an overhaul due to such and such not being secure anymore, or whatever their excuse might be, so it could take time and cost more than you expect. Watch out for ballooning costs and make sure you get a clear plan down before agreeing anything.

-

If it were me, I would build the site myself. But, there are a couple of things you need to consider (and this is coming from my experience working with on the web for around 26 years, and as a pro webdev for nearly 20 years).

This is a slightly long post (sorry, I truly did not mean to write an essay) but I hope that it will quell your concerns, encourage you, and help you on your journey as a webdev.

The first point is about time - if you ask this other team to update the site, you will have more time to do other things. If you have something else that is important to you, that you need to attend to, then it would make sense to ask that team to do the work. I suspect they will likely tell you the site needs to be totally re-written somewhere along the line, and it might turn out to take more time and money than you expect, but at least you would be free to pursue other things. The second point I would raise is that if you build the site, you have to maintain it. If you build the site well, you can sleep at night. If you don't, you might get a call at 8pm before you are thinking about finishing for the day saying there is some problem with the site. In fact, even if you build the site really well, you will still get edge cases where someone will inform you of an issue, with limited information, you may end up spending hours to work out what the issue is (and indeed, if there even is one). I've experienced this a couple of times over the years, fortunately it's very very rare, but it's always a possibility.

Considering the two points above, if you decided to build the site yourself, I would have the following suggestions: Build the site with SvelteKit, FaunaDB and CloudFlare (Workers and CDN). There are a LOT of tools around, and there are always new ones just around the corner, but working with the above tools has been a game changer for me. This is all serverless based. It has the capacity to serve hundreds of thousands of simultaneous users in a way that PHP/MySQL could only dream of (and PHP/MySQL has been my bread and butter for most of my webdev career).

1. It does this at a controlled cost : (CloudFlare Workers) In quiet times it scales down, you pay almost nothing to keep things going, and when the site is busy it scales to support the users, however as many as there are. Many firms have made this claim over the years about various tech, but I think that with Cloudflare Workers it really is true. Performance is fast, reliable, it scales smoothly, and cost is kept in check. I notice you have put Deno in your stack which is a V8 runtime (I think this is pretty much the same as Cloudflare Worker’s V8 runtime, though someone correct me if I am wrong). I have no experience with Deno though.

2. Less time is needed to maintain servers : I have a few sites on a hosting provider in the US where they manage the servers, I’m also using AWS where I have to maintain the servers. The reason I use AWS is because I needed sites served in Japan, on a fast backbone, and because I was PHP/MySQL based they seemed to have everything I needed (I looked at a lot of other TRADITIONAL hosting options here in Japan, but AWS reliability, scaleability and functionality simply beats them all, even if it is not the cheapest). There are some issues though. If you have a site that is going to be potentially very very busy (even for short periods of time) you need to set up load balancing. There are various ways of doing this on AWS, trying to figure out the best reliability/performance/cost path is not easy - I read so much documentation I started dreaming about it. If you have load balancing in place, and the site is not busy, you are burning money. On the other hand, if it cannot support the current number of users, you have to scale up quickly, preferably before you get into that situation otherwise you are going have a poor user experience (which I truly dislike) and will lose customers. Of course, for best performance (and control of costs), you would probably set up your own server via EC2. You have to maintain that server. I’ve never had a server go down, fortunately, but it’s certainly a possibility. You have to maintain that too. This all takes up valuable time. It’s not a marketing thing, it’s a real down to earth problem that is solved going the severless route. It really truly does. Which is why I recommend Cloudflare.

3. Why Svelte? (or, how did I get here) : I’ve written several large web applications from scratch over the years. I amassed a large library of my own modules that I have refined over the years including tools to support the development process itself (performance, trace, logging, etc). For about a year or so, a decade ago, I used Drupal 6/7 (which was a nightmare for many different reasons, and caused lock-in). I built several sites with it, but it always seemed to require more work and had a lot of issues with maintainability later on (I bring this point up, because I have experienced the ‘promise’ of new tech several times, Drupal was one of them). After this I ended up building my own framework from scratch in PHP because I wanted to make sites I built as fast and lean (yet fully featured) and be the least memory intensive as possible - in order to serve as many concurrent users as possible. Full user account management, security with roles, forms that build themselves (pretty much) because the system knows how tables are related (I was really proud of this because I could build a form programatically with just a few lines of code, fields are protected from invalid input, user access controlled view/edit, etc.) I designed the whole stack setting up my servers on AWS, tuning Apache and PHP to be as fast as possible. Memory use for building a fully constructed page was under 2mb, and generation took a millisecond or so (actually can’t recall the exact number, but it is VERY fast).

I spent over half a year last year working every day. I mean, truly, every day. I didn’t have a single day to stop and rest for over half a year because there just wasn’t time. Towards the end of last year the project got paused for various reasons. It was used for demos to clients, which was immensely important for our business, but was not put into full production as it wasn’t 100% finished. I took a break. Worn out, and pretty disappointed. I bring this up because when you put a lot of hard work into something, you don’t usually want to let it go. There has to be a damn good reason to take another path after that.

Over the years I looked at many different frameworks, CMs, and other curiosities - each time wondering "would it be worth investing time in this?" After being burned by Drupal many years ago, I had pretty strong reservations about locking myself into someone else's code base.

Earlier this year I started on a new project - I had all my tools I had already built. I could build the new site in around two months with all the existing tech I had, and I would probably have much free time to myself. Having designed the new system, prepared the database, I starting thinking about improving the page design and better user interaction (of all things right?) I looked at various javascript frameworks. My thinking was - I’ve got the server side down, I’ve got the content management down, let’s see what more we can do with the front end. And I discovered Svelte. I saw Richard’s demo from back in 2017. My world exploded from that moment on (where the hell had I been?)

It needs a serverless server (I’d heard of these and it didn’t make much sense to me way back when - losing control of the servers, who would possibly agree that was a good idea?) However, I looked into it more, and ‘saw the light’ so to speak. While there are a lot of options I decided that ultimately Cloudflare made the most sense to me. And the journey began.

The point of all of the above post is that I am not one to jump ship. I am not interested in the latest fad. There needs to be something truly substantive for me to decide to invest the time needed to move to a different stack.

I still haven’t answered the question - why Svelte? You might wonder - why on earth would I change after all that hard work I had already done for my PHP based framework (which actually has a Javascript side with lots of modules for different things as well), to using Svelte? Because it is, in my opinion: the future of webdev. Yes, there might be a new framework years down the line that could take over (never say never) but right now it is so well thought out, so well put together, and so forward thinking, it just doesn’t make sense not to invest time and use it. It’s similar to a few other frameworks (next, react, etc), but different enough, that it’s a totally different beast. The amount of code you have to write is lower, readability is better (this is REALLY important, and many programmers learn way late in the game how to write code that is readable - we often get stuck on performance; readability be damned). Code manageability is great, separation and modularity of code is pretty good, I’ve been very impressed with it.

Now that you can understand a bit of my background, and my journey here, I’m going to try to answer some of your other questions.

If you build the site yourself, you are not just committing to building the site, you are also committing yourself to building other sites later down the road (otherwise it is likely not worth the amount of time you will have to put in to building the booking site.) Given how functional the Svelte, FaunaDB, Cloudflare stack is, if you get the stack down, then future development time will be significantly reduced, and the sites you build will be fast and robust. The bonus is that you won’t have to keep an eye on them in quite the same way you would have to in a traditional non serverless hosting environment, costs are kept low, performance is good, and you can serve how ever many users you need to. Less stress, more time.

Both Svelte and FaunaDB are young. They are still developing, but I like the direction they are taking, and I think they are likely to take more and more market share of the webdev sphere - so having a good knowledge of them will most likely serve you well into the future.

There are a couple of holes in Svelte at the moment. Internationalisation for example is not really there, encrypted cookies with Svelte and Cloudflare was problematic for me as one of the usual Cookie modules for Svelte (not a standard inbuilt Svelte module, but something written by a contributor) uses an encryption module that is not compatible with Cloudflare (so this is really an issue with Cloudflare). Their VM is not 100% Node compliant, just so you know. Despite the issues I have had, I’m still steadfast in my belief that this is the right direction to take.

I hope that this post is useful to someone. If you have questions, just ask! Good luck with whatever you decide.

Edited to correct "CloudFlare (Works and CDN)"; and later to correct formatting.

If these three are your options, I would recommend going with Auth0. They have all functionality available as developer API (Okta e.g. not) so you can manage your instance with Infrastructure as code and can also easily add functionalities relatively easily with the API. They are also really powerful if we're talking about ABAC (Attribute based access control). You can also enrich your access token with custom claims from your MongoDB, that can be probably really useful, as you said that you're dealing with multi tenancy.

We're using Auth0 in combination with Fauna Fauna is a database, so it would challenge you're mongodb. But Faunadb is the first database that implemented a full end user ABAC system directly in the database. (And also a lot easier than the ABAC systems from Okta or Auth0). This helps us, to use Auth0 only as identity platform and doing all the authorization with enriched claims over Fauna. With that you can skip in a lot of the cases you're backend, and you can request directly from the frontend your database (Blazing fast). Also, you can replace in some years Auth0 a lot easier with some upcoming cheaper (Auth0 was bought by Okta for a hilarious price) and "easy to use" passwordless identity provider like Passage.id