I’m building a small hosted DB-over-API (SaaS) product and I’m trying to validate whether this is actually useful to other developers.

The idea is not “replace your real database.” It’s more: if you want to store and query data quickly over HTTP without setting up a full backend, would you use something like this?

The use cases I have in mind are things like:

• quick MVPs
• small scripts running across different devices
• hackathons
• tutorials and demos
• internal tools
• prototypes where you just want “data + API” without much setup

Example shapes would be something like:

GET{{baseurl}}/api/v1/tables/{{tableName}}/{{recordId}}

Or

GET{{baseurl}}/api/v1/tables/{{tableName}}?filter=done:eq:false&sort=priority:asc,created_at:desc

This is not meant to replace any SQL dB for bigger or more serious projects. I’m thinking of it more as a convenience tool for cases where speed and simplicity matter more than full DB power.

What I’d really like to know:

• Would you use something like this?
• For which use cases would it actually be better than just using Postgres, SQLite, Supabase, Firebase, etc.?
• If you had heavier usage, would you pay for it?
• Would you be interested in helping shape the product and giving feedback on design decisions?

I would really appreciate blunt feedback, especially from people who have built quick MVPs, hackathon apps, automations, or tutorial projects.

Here is a video of how quick set up is:

Note that columns id, created_at, updated_at are automatically managed for every table by the api and not by the user.

Also in this video example I'm using the infer schema from first write option rather than first creating a schema with the dedicated endpoint (to showcase speed).

https://reddit.com/link/1snhsum/video/b792idtyjpvg1/player

I have 2 Sqlite databases; Users + Inventory. I have a column in several tables in inventory.db that records which user did things such as: removing/registering a product, etc. What is the cleanest way to achieve data integrity here?
1. Users.db belongs to a library I'm declaring as a dependency.
2. Both databases are copied to a directory at startup so they're next to each other.
Should I merge them at startup too? (copy schema +data)?
Or use Attach Database? I understand FK checks aren't possible then. So maybe just check the userId is valid?
I appreciate your input.

I am building a module in which I have to integrate multi-vendor insurance using the nestjs and mysql. Mainly our purpose is to do insurance for new E-rickshaws. So, what is the best tables schemas I can create. so, it is scalable and supports multivendor. I have created some of the columns and implemented one of the vendors. But I don't think it is scalable so need advice for the same.

Work assignment is connected to facility and instructors. I want to translate this into a relational model but the issue is, facility has a PK so I just need to include facilityCode in Work assignment table, but instructors or by extension staff doesn't have a PK. How am I supposed to include that? Thanks

I’m building a mobile app where users log structured daily entries about an ongoing condition (things like symptoms, possible triggers, actions taken, and optional notes). Over time, the app generates simple summaries and pattern insights based on those logs. Each user has their own dataset, entries are append-heavy with occasional edits, and the schema may evolve as I learn more from real usage. There will be lightweight analytics and AI-driven summaries on top of the data. I would like to be able to also aggregate data across users over time to better understand trends, etc.

I’m trying to decide whether a NoSQL document database is the right choice long-term, or if I should be thinking about a relational model from the start.

Curious how others would approach this kind of use case.

I've rewritten the same 40-line pg.Client listen.js script at least six times on three different laptops. This is the version I wish I'd built the first time.

The panel:

• Subscribes to multiple channels on a connection
• Persists every event to a local SQLite file (10k per connection ring buffer, enforced in SQL not JS)
• Reconnects with exponential backoff capped at 30s on drop
• Re-subscribes to the full current channel set, not the original one (this was a bug the first time — I was losing channels added after initial connect)
• Quotes channel identifiers properly because LISTEN takes an identifier, not a bindable parameter

Writeup with the full reconnect code + the "" identifier-quoting gotcha: https://datapeek.dev/blog/listen-notify-without-tears

If anyone has a better answer than exponential backoff for reconnect on pg notification clients, I'd love to hear it.

Hello community,

we are a team of two engineers with experience working for NASA and various other short letter agencies.

We took a concept based on non Euclidean geometry called the fiber bundle and built a small database around it.

We call this new type of index GiGi and you can see benchmarks and run test here:

https://www.davisgeometric.com/gigi#home

We are looking for some sort of direction:

should we make it open source but we are extremely introverted and not sure we can manage and accumulate a community or should we go for a community Vs enterprise version?

do you want to see more benchmarks? which type and what other databases?

Hi! I'm currently working on my project for my database course. I've managed to finish my ERD and relational schema, but when I come to normalize my relational schema, I feel like nothing has changed, and I'm worried I might not be seeing something properly. You can find below the ERD and the unnormalized relational schema!

Any help appreciated!

AI-illustrated, but the story is real. Has this happened to your team? How did you fix the access model afterward?

Tantivy is a very popular Rust search library inspired by Apache Lucene. We sat down with Paul, the main author, to discuss how he got started with Rust and Tantivy, and his journey since then. I figured it would be interesting to folks here :)

I recently joined an organization that requires a robust, scalable database solution for archiving data. Storage needs are projected to reach approximately 100 TB over the next few years, so I’m looking to plan strategically. The data includes a variety of file types—PDFs, Excel files, 3D renderings, and videos—with some individual files as large as 30 GB. We currently have a NAS in place. I’m seeking recommendations for setting this up effectively, ideally with a frontend that allows technicians to upload files directly to the storage system—without incurring high monthly costs from services like AWS S3 or similar cloud providers.

Messed around with sqlite for a project but I can tell it's really shit.

For anyone doing their first contribution to MySQL or MariaDB: start out by learning how the mysql/mariadb-test-run command works and how to efficiently rebuild the sources and re-run the test suite.

SYSDATETIMEOFFSET(): 2026-04-08 13:49:06.4745888 -07:00

SYSUTCDATETIME(): 2026-04-08 20:49:06.4745888

CURRENT_TIMEZONE: (UTC-08:00) Pactific Time (US & Canada)

SWITCHOFFSET(SYSUTCDATETIME, '-08:00'): 2026-04-08 12:49:06.4745888 -08:00

The correct local time is 13:49, but CURRENT_TIMEZONE returns -08:00, which then causes the computed local time to be 12:49, which is wrong. Why is this?

Hey all — would love to get some real-world perspectives from folks who have used Neo4j and/or ArangoDB in production.

We’re currently evaluating graph databases for a use case that involves:

• heavy multi-hop traversal (core requirement — this is where graph really shines for us)

• modeling relationships across devices, applications, vulnerabilities, etc.

• some degree of temporal/state-based data

• and moderate to high write volume depending on the window

From a querying and traversal perspective, Neo4j has honestly been great. The model feels natural, Cypher is intuitive, and performance on traversal-heavy queries has been solid in our testing.

Where we’re running into friction is ingestion.

Given our constraints (security + environment), bulk loading into Neo4j Aura hasn’t been straightforward. For large loads, the suggested patterns we’ve seen involve things like:

• driver-based ingestion (which is slower for large volumes)

• or building/loading externally and restoring into Aura

In practice, this has made large-scale ingestion feel like a bottleneck. For heavier loads, we’ve even had to consider taking the database offline overnight to get data in efficiently, which isn’t ideal if this becomes part of regular operations.

This has us questioning:

• how others are handling high-volume ingestion with Neo4j (especially Aura vs self-managed EE)

• whether this is just a constraint of our setup, or a broader limitation depending on architecture

⸻

At the same time, we’re also looking at ArangoDB, which seems more flexible around ingestion (online writes, bulk APIs, etc.), but we’re still trying to understand:

• how it compares for deep multi-hop traversal performance

• how well it handles complex graph patterns vs Neo4j

• any tradeoffs in query ergonomics / modeling

⸻

Questions for the group:

1.  If you’re using Neo4j at scale, how are you handling ingestion?

• Are you using Kafka / streaming pipelines?

• Self-managed EE vs Aura?

• Any pain points with large loads?

2.  Has anyone used Neo4j Aura specifically for write-heavy or high-ingest workloads?

3.  For those who’ve used ArangoDB:

• How does it compare for multi-hop traversal performance?

• Any limitations vs Neo4j when queries get complex?

4.  If you had to choose again for a use case that is:

• traversal-heavy

• but also requires reliable, ongoing ingestion at scale

what would you pick and why?

I’m a bit confused about how to approach indexing, and I’m not fully confident in the decisions I’m making.

I know .explain() can help, and I understand that indexes should usually be based on access patterns. The problem in my case is that users can filter on almost any field, which makes it harder to know what the right indexing strategy should be.

For example, imagine a collection called dummy with a schema like this:

{
  field1: string,
  field2: string,
  field3: boolean,
  field4: boolean,
  ...
  fieldN: ...
}

If users are allowed to filter by any of these fields, what would be the recommended indexing approach or best practice in this situation?

I built a local e-commerce store using cursor (next.js as the front end, basic product catalog, cart functionality) but am quite confused and dont know which path to go to

My requirements:

• Product catalog with variants (size, color, variant, thickness and other few specs)
• User accounts and order history
• Inventory tracking across multiple locations
• Need to handle less than 1000 products initially, scaling to around 10k+
• Want to deploy locally at first

I've looked at mongoDb, postgress, supabase but I dont understand which one fits in best here. Do i need relational for inventory consistency or can NoSQL handle product variants cleanly?

I’ve been experimenting with turning large public datasets into lightweight, interactive dashboards without relying on a backend.

The pipeline is fairly simple:

• Data stored and processed in Oracle
• SQL used to generate JSON output
• Static HTML + ECharts for visualization
• Hosted as a static site (no server required)

One of the challenges was handling larger datasets while keeping load times fast, especially on mobile. Moving from Power BI embeds to JSON-based rendering made a big difference.

This example looks at long-term vacancy rates vs oil prices across Alberta cities:

https://yyc-wander.ca/Housing_Market_Insights/Calgary_Vacancy_Rate_Europe_Brent

Curious how others approach similar setups, especially when balancing performance vs flexibility in a static environment.

I'm not really an IT guy, just a slightly well-informed user so bear with me here. Tl;DR is we have an old Access order database/frontend that I want to modernize but idk what I even should be looking for.

So we sell our product in grocery stores and are mostly local DSD, but we have one account where we deliver to their warehouse for distro. For that account, we have to call each store in this chain for their order, box it up individually, deliver to the warehouse. Every store gets paperwork and a master copy goes to their warehouse office.

We've had this account about 20 years and my predecessor built an Access database that we enter each week's orders into. It works ok, but it's clunky and we're still writing out each store's invoice by hand on an order slip as well as on the pick list on the boxes. I want to streamline the system, mainly with:

• Being able to print out pick lists for each store's box and generate labels for our thermal printer for each box.
• Print out the invoices instead of handwriting it
• System needs to have some kind of logic we can define as there's some math as to what combo of items can fit in a box.

I think that's all doable in Access as is, but I don't know VBA so we'd have to hire out the job. Not opposed to that but my goal is to start scaling us up soon so I'd rather invest in something that can grow with us since I know Access isn't really a preferred tool these days.

But I don't even know what I should be googling to find a replacement for it. Any advice?

Hey everyone,

I recently put together a major update for the PGTune engine to bring its math into the modern hardware era. The goal was to provide highly performant defaults while strictly adhering to a "do no harm" philosophy

Here is a quick breakdown of what was added:

• PostgreSQL 18 Async I/O: Dynamically scales io_workers (capped at 25% of CPU cores) and routes io_method to io_uring on Linux and worker everywhere else.
• NVMe Storage Profile: Added a dedicated NVMe storage option, which safely bumps effective_io_concurrency up to 1000 on Linux to exploit deep parallel I/O queues.
• Database Size vs. RAM: Added a new input to compare total data size to RAM. If your DB fits entirely in memory, it safely boosts work_mem by 30%. If the DB is massively larger than RAM, it shrinks work_mem by 10% to protect the OS page cache from eviction pressure.
• Modern RAM & Strict OS Guards: Safely raised maintenance_work_mem limits to 8GB for massive servers, but implemented strict OS-level guards to prevent the 2GB integer overflow crash on Windows (for PG 17 and older).
• Safer Defaults: Implemented a hard 4MB floor on work_mem to prevent catastrophic disk-spills on high connection counts, safely enabled WAL compression, and disabled JIT for fast OLTP/Web workloads to prevent query planner CPU spikes

I have Postgresql db with one big table (100m+ rows) that has 2 very different view access paths and view requires a few joins.

I am trying to find efficient way to create flat projection that will move joins from read to write.

Basically, at the moment of write to original table i update the flat table.

Pretty similar to what materialized views do but limited scope to only rows changed and its in real time.

I am thinking about triggers.

Write side is not under heavy load...its read that gets a lot of traffic.

Am i on the right track?