Disclaimer:

1. I'm the author of GraphJin https://github.com/dosco/graphjin

2. This is an opinion piece therefore it is my subjective opinion.

3. I use both REST and GraphQL

I've spent years building products with REST APIs and it's always felt like I'm forcing a square peg into a round hole Everything with REST is a a struggle and cognitive drain, mapping HTTP error codes to your response types, picking between PUT, PATCH and POST, coming up with URL path names, resource vs view specific APIs, having to build batch APIs, coming up with url paths for these APIs and the worst of them all inventing a query and filtering language that you then have to squeeze into a url query string.

People say REST is a standard but that not really true, it's not. I feel I've seen every possible liberty taken by those building with REST including once where someone was using GET requests for backend database mutations and don't even get me started with HTTP error codes.

Even when starting off with a popular framework this complexity catches up and you often end up writing a ton of database code for every operation on every resource and then having to maintain all of that to eternity. To add to this work load the API is constantly changing to meet the demands of rich and fast changing product interfaces. You're always blocking someone and this takes a toll. Soon tech debt starts to creep in, let's just add this one off param here and let's just break out rules there.

GraphQL is a breadth of fresh air or like Steve Jobs puts it a bottle of cold water to someone in hell. GraphQL is exactly what 90% of app development is about - querying the exact data you need. It is a language for writing queries. REST is a fancy name given to HTTP and is best for when you want to send HTML back and forth. Building with REST vs GraphQL feels like using a CSV file vs a real database for managing your data.

To me the best thing to come out of the GraphQL world is the GraphQL to SQL compilers like GraphJin, Hasura and Postgraphile. I used GraphJin to build 42papers.com and besides spending a day on the database schema I literally had zero backend code to write. My entire focus could now be on the experience and building the web UI that touches users. It was almost magical to be able to just write out a GraphQL query when building a view and have all the data I need. This focus gave me the freedom to build a better product, iterate faster and bring my vision to life instead of trying to figure out what HTTP error code is the right one.

Any startup using a GraphQL to SQL compiler like GraphJin or Hasura will run circles around those who don't. And as the database improves the new capabilities will be automatically leveraged by these compilers to generate more efficient queries. Features like rate-limiting, tracing, compression all comes out of the box and continue to improve without you having to change a line of code. Even capabilities that I would not have dreamed of like efficiently subscribing to database changes from the browser are as simple as using the word `subscription` instead of `query` in your GraphQL.

GraphQL makes all of this possible it frees your developers from doing boring boilerplate work and instead focus on the meaty and valuable parts of your app. I'm glad I don't have to waste time on something commodity like manually writing SQL queries to a database and instead have the computer do it for me. To build better products developers happiness is as important as the user happiness.

The projects mentioned in this post

GraphJin

https://github.com/dosco/graphjin

Hasura

https://github.com/hasura/graphql-engine

Postgraphile

https://github.com/graphile/postgraphile

Apollo to manage the local state of you app? Say what… 🤔

I published my 5th article! Let me know what you think 🤓✨

Over the past 2 months, we've delved deep into the preferences of jobseekers and salaries in Germany (DE) and Switzerland (CH).

The results of over 6'300 salary data points and 12'500 survey answers are collected in the Transparent IT Job Market Reports. If you are interested in the findings, you can find direct links below (no paywalls, no gatekeeping, just raw PDFs):

https://static.swissdevjobs.ch/market-reports/IT-Market-Report-2023-SwissDevJobs.pdf

https://static.germantechjobs.de/market-reports/IT-Market-Report-2023-GermanTechJobs.pdf

GraphQL is currently one of the most frequently mentioned technologies when it comes to innovation in the API economy. Adopters enjoy the ease of use and tooling like for example GraphiQL, the browser-based user interface to try out any GraphQL API. The whole experience of GraphQL is exactly what frontend-developers need to build amazing interactive web applications.

However, with the rise of adoption, I'm starting to get more and more concerned about the way people understand GraphQL and use it. In this post, I'd like to share my unpopular opinion on what GraphQL really is meant to be and why you should be concerned if you're using it the popular-but-risky way.

Read more: https://wundergraph.com/blog/graphql_is_not_meant_to_be_exposed_over_the_internet

Y'all really made pretty significant breaking changes with v4 and then decided to shove them down everyone's throat by immediately deprecating v3 with an EOL only one year after v4 was generally available??? I only started this project for my work in the summer I'm the only one working on this server and now I already have a couple days worth of technical debt to sort out through zero fault of my own.

In bird culture this is known as a dick move. A release that is scarcely a year old deserves more support.

Well, I personally like using Graphql (especially with AWS AppSync). However, although being around for a few years, it has not become a big thing that everybody wants to convert to. Sure, presentations about its power are still held in tech talks among enterprise teams, the nextgen static web app frameworks praise using it; but it has not hit the potential and not likely to get there maybe: Even the most enthusiastic articles are mostly from 2016-2019.

Will GraphQL start to real excite the industry later, or did it already flattened its hype curve?

Can anyone tell me if it has scope or not the pricing would be 5$ per student / month
i have lot of thing to write here but .... i'm tired LOL.
i have connection with some schools , so i will market it personally and sell it to the schools

Modules :

1. user management , Role base Auth

2. Attendance via NFC

3. LMS , learning management system

4. Time table

5. GPS based attendance marking for teachers

6. Performance tracking of student & student .

7. Grades, and Reports

8. Sitting Plans for examinations

9. Announcements

whats your POV on this

TECH STACK:

• server: graphQL Apollo OR Yoga ?

• schema/validation : type-graphql

• node server : express OR Hono please recommend

• ORM : drizzle OR Prisma , my choice is drizzle , please recommend.

• Database: PostgresSQL

• client: urql with caching enabled

• frontend : nextjs

• codegen for generate types

Note: Please tell me what i am missing here , like how can i use postgraphile into this ? do i actually need to use it or not ?

r/graphql community helps me a lot , and i have cleared many doubts here related to graphQL and its clients.
i hope you guys help me to build the initial mono-repo project setup.

Thanks
Rohan (codebloded)

GraphQL  is a hot technology. Its recent rise created a niche for multiple tools having one thing in common - making using GraphQL easier & more pleasant experience, one of them is GraphQL Code Generator: https://blog.graphqleditor.com/graphql-code-generator/

Hey everyone,

A few weeks ago I released the initial CLI version of my project (formerly called Glia, now ArcRift) on Reddit. The response and feedback from the community were incredible. Today, I'm excited to share the massive v1.6.1 update, which transitions the project from a headless script into a fully standalone native Desktop Application.

ArcRift is a 100% offline, local-first RAG and memory layer. It is designed to bridge the gap between your AI web chats (Claude, ChatGPT, DeepSeek) and your local developer tools (Cursor, Windsurf, Claude Code) using a unified local database.

I completely rebuilt the storage layer to remove heavy Docker dependencies. It now uses a zero-bloat Node.js + Tauri architecture, running sqlite-vec (for 768-dim float32 embeddings) alongside FTS5 for hybrid search, powered entirely by local Ollama instances.

We just launched a live website that outlines the details and demonstrates the features in action:

• Website: https://arcrift.vercel.app/

• Codebase: https://github.com/Eshaan-Nair/ArcRift

Technical Stack & Features in v1.6.1:

• Native Desktop App (Tauri): The background service is now wrapped in a lightweight desktop executable. It sits in your system tray and manages the SQLite database natively in your OS AppData folder—no terminal required.

• Direct Codebase Indexing (Local File RAG): An expansion to the MCP server that allows ArcRift to scan and index your actual project files into the graph, bridging the gap between conversational memory and actual code architecture.

• Hybrid Search Retrieval: SQLite-vec (using nomic-embed-text locally) + FTS5 keyword prefix matching (porter stemmer).

• Surgical Sentence-level Trimming: Chunks are sliced into sentences. When a prompt is intercepted, only the exact matching sentences are pulled out of the vector store instead of the whole paragraph. It cuts LLM prompt bloat by ~90-95% in my benchmarks.

• Knowledge Graph Extraction: An offline task queue uses a local LLM to extract entity triples (subject-relation-object). These are stored in a SQLite facts table and fused with the vector retrieval score.

• Concurrency: Running SQLite in WAL (Write-Ahead Logging) mode allows the browser extension dashboard and active MCP sessions to read/write concurrently without locking.

• PII Redaction: Aggressive scrubbing of JWTs, API keys, emails, and IPs in the extension before data is saved.

The extension works on Claude.ai, ChatGPT, DeepSeek, Gemini, Grok, and Mistral. The MCP server runs out of the same backend database for your terminal agent or Cursor.

For desktop users, you can grab the .exe from the GitHub releases. For developers who want headless mode, you can still set it up with a single command: npx arcrift-setup

ArcRift is completely open-source (MIT). If you like the local-first approach or want to contribute to the SQLite vector pipeline, PRs are very welcome, and a star on GitHub helps the project get discovered!

I would appreciate any feedback on the new Tauri desktop architecture or the local graph extraction performance!

https://github.com/FormCMS/FormCMS

the idea is if you modeling entities in the system, the system can generate graphQL field automatically.

How does it resolve some common GraphQL issues?

Key Challenges

1. Security & Over-Fetching – Complex or poorly optimized queries can overload the backend, exposing vulnerabilities and impacting performance.

2. Caching Limitations – GraphQL lacks built-in CDN caching, making performance optimization harder.

3. N+1 Query Problem – Individual resolver calls can lead to inefficient database queries.

Solution: Persisted Queries with GET Requests

Many GraphQL frameworks support persisted queries with GET requests, enabling caching and improved performance.

How FormCMS Solves These Issues

FormCMS automatically saves GraphQL queries and converts them into RESTful GET requests. For example:

query TeacherQuery($id: Int) {   teacherList(idSet: [$id]) {     id firstname lastname     skills { id name }   } }

becomes GET /api/queries/TeacherQuery.

• Security & Efficiency – Only Admins can define GraphQL queries, preventing abuse. Backend and frontend teams optimize queries to avoid excessive data requests.

• Caching – GET requests enable efficient CDN caching, while ASP.NET Core’s hybrid cache further boosts performance.

• Performance – Related entities are retrieved in a single optimized query, avoiding the N+1 problem.

By transforming GraphQL into optimized REST-like queries, FormCMS ensures a secure, efficient, and scalable API experience.

Hey r/[subreddit]! 👋

I've been working on FormCMS — an open-source, AI-powered CMS that lets you describe what you want in plain English and generates the full stack for you: database schemas, seed data, GraphQL queries, and complete UI pages.

What makes it different?

Most CMS tools give you a content editor. FormCMS gives you an AI development partner:

• "Design entities for a library system" → generates your schema with relationships

• "Add sample data for books" → populates your database

• "Create a page to display all books" → builds a fully functional, data-driven UI page

You can even say things like "Add a like button" or "Show user avatar" and it just works — the AI figures out the layout, the components, and the wiring.

Who is this for?

• Frontend devs: Run FormCMS via Docker, build your app with React/Vite, and let AI handle the backend. No .NET experience needed.

• Non-developers: Build dynamic, database-driven pages without writing code. Describe what you want and AI handles the rest.

Performance

It's not just a toy — P95 latency under 200ms, 2,400+ QPS. Supports SQLite, PostgreSQL, SQL Server, and MySQL.

Try it now

🟢 Live demo: formcms.com/mate (login: [email protected] / Admin1!)

Or run it locally in 10 seconds:

docker run -d \
  --name formcms \
  -p 5000:5000 \
  -v formcms_data:/data \
  -e DATABASE_PROVIDER=0 \
  -e "CONNECTION_STRING=Data Source=/data/cms.db" \
  -e FORMCMS_DATA_PATH=/data \
  jaike/formcms-mono:latest

Then open http://localhost:5000/mate.

Built with FormCMS

Zen Health Tracker — a full health tracking app built in hours using FormCMS + an AI coding agent. Zero manual coding.

GitHub: github.com/formcms/formcms

Would love your feedback! What features would make this more useful for your workflow?

I made a mutation “CreateFish”, do I add the resolver on the same page as my mutation? I added it to my Typedefs, so which file should I use for the resolver? Or is that already made?

A short blog post about mistakes you should avoid when getting started with GraphQL https://blog.graphqleditor.com/Five-mistakes-to-avoid-when-getting-started-with-GraphQL/

Could someone look into this? I was unable to copy paste properly formatted code here

https://stackoverflow.com/questions/60346591/graphql-authentication-with-react-typescript

Hello.

Graphql seems pretty cool.

I am having trouble understanding how to, and how to google the proper way to deploy a graphql api.

What I used to do is a) create db, b) create a flask app, (sever to localhost), then c) use gunicorn to serve it to the web.

Currently I am able to build https://github.com/grand-stack/grand-stack-starter I added new nodes, added new components... but everything is connected via localhost.

I want to make an ec2, and serve this to a normal address like: x.x.x.x:y/graql
I need to do this, so I can share one graph among multiple developers... its time to go from POC to group play time.

I have seen stuff about using lambda... but lambda doesnt have a public end point...
I have seen a lot of stuff with localhost... but that doesnt help me..

I have seen stuff with other cloud providers... but realistically we already have an aws account amongst my hobby group so it would be ideal to not branch into other cloud providers unless a very good reason can be made.

tldr: how do we make public endpoints?

Thanks for your help.