Alternatives to Hasura

I was building a personal project that I needed to store items in a real time database. I am more comfortable with my Frontend skills than my backend so I didn't want to spend time building out anything in Ruby or Go.

I stumbled on Firebase by #Google, and it was really all I needed. It had realtime data, an area for storing file uploads and best of all for the amount of data I needed it was free!

I built out my application using tools I was familiar with, React for the framework, Redux.js to manage my state across components, and styled-components for the styling.

Now as this was a project I was just working on in my free time for fun I didn't really want to pay for hosting. I did some research and I found Netlify. I had actually seen them at #ReactRally the year before and deployed a Gatsby site to Netlify already.

Netlify was very easy to setup and link to my GitHub account you select a repo and pretty much with very little configuration you have a live site that will deploy every time you push to master.

With the selection of these tools I was able to build out my application, connect it to a realtime database, and deploy to a live environment all with $0 spent.

If you're looking to build out a small app I suggest giving these tools a go as you can get your idea out into the real world for absolutely no cost.

Your tech stack is solid for building a real-time messaging project.

React and React Native are excellent choices for the frontend, especially if you want to have both web and mobile versions of your application share code.

ExpressJS is an unopinionated framework that affords you the flexibility to use it's features at your term, which is a good start. However, I would recommend you explore Sails.js as well. Sails.js is built on top of Express.js and it provides additional features out of the box, especially the Websocket integration that your project requires.

Don't forget to set up Graphql codegen, this would improve your dev experience (Add Typescript, if you can too).

I don't know much about databases but you might want to consider using NO-SQL. I used Firebase real-time db and aws dynamo db on a few of my personal projects and I love they're easy to work with and offer more flexibility for a chat application.

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.

We are starting to build one shirt data logic, structure and as an online clothing store we believe good ux and ui is a goal to drive a lot of click through. The problem is, how do we fetch data and how do we abstract the gap between the Front-end devs and backend-devs as we are just two in the technical unit. We decided to go for GraphQL as our application-layer tool and Prisma for our database-layer abstracter.

Reasons :

GraphQL :

1. GraphQL makes fetching of data less painful and organised.

2. GraphQL gives you 100% assurance on data you getting back as opposed to the Rest design .

3. GraphQL comes with a bunch of real-time functionality in form of. subscriptions and finally because we are using React (GraphQL is not React demanding, it's doesn't require a specific framework, language or tool, but it definitely makes react apps fly )

Prisma :

1. Writing revolvers can be fun, but imagine writing revolvers nested deep down, curry braces flying around. This is sure a welcome note to bugs and as a small team we need to focus more on what that matters more. Prisma generates this necessary CRUD resolves, mutations and subscription out of the box.

2. We don't really have much budget at the moment so we are going to run our logic in a scalable cheap and cost effective cloud environment. Oh! It's AWS Lambda and deploying our schema to Lambda is our best bet to minimize cost and same time scale.

We are still at development stage and I believe, working on this start up will increase my dev knowledge. Off for Lunch :)

Oof. I have truly hated JavaScript for a long time. Like, for over twenty years now. Like, since the Clinton administration. It's always been a nightmare to deal with all of the aspects of that silly language.

But wowza, things have changed. Tooling is just way, way better. I'm primarily web-oriented, and using React and Apollo together the past few years really opened my eyes to building rich apps. And I deeply apologize for using the phrase rich apps; I don't think I've ever said such Enterprisey words before.

But yeah, things are different now. I still love Rails, and still use it for a lot of apps I build. But it's that silly rich apps phrase that's the problem. Users have way more comprehensive expectations than they did even five years ago, and the JS community does a good job at building tools and tech that tackle the problems of making heavy, complicated UI and frontend work.

Obviously there's a lot of things happening here, so just saying "JavaScript isn't terrible" might encompass a huge amount of libraries and frameworks. But if you're like me, yeah, give things another shot- I'm somehow not hating on JavaScript anymore and... gulp... I kinda love it.

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.

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.

Hi, I went through a comprehensive analysis - of headless/api content management systems - essentially to store content "bits" and publish them where needed (website, 3rd party sites, social media, etc.). I had considered many other solutions but ultimately chose Directus. I believe that was a good choice.

I had strongly considered Contentful, Strapi, Sanity, and hygraph. Hygraph came in #2 and contentful #3.

Ultimately I liked directus for:

(1) time in business

(2) open source

(3) integration with n8n and Pipedream

(4) pricing

(5) extensibility

Thoughts? Was this a good choice? We have many WordPress sites we're not (at least now) looking to replace with Directus, but instead to push to.

I'd love some feedback.

Hello everyone.

I want to know how platforms like FaunaDB and Back4App handle the user data and what stacks anyone can choose to create such a platform (Any references are welcome).

Things I would like to know.

1) How to handle such large unstructured data without caring about scalability 2) How multiple users applications and API can be managed from one dashboard (example back4App or faunaDB)

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.