
Ask HN: What's the fastest tool for basic CRUD? - xupybd
I like to throw together small tools to automate things. Most involve Crud screens. Simple Crud screens are all very similar but seem to take a lot of time to throw together. Are there good tools that allow you to throw these up quickly?
======
artpar
I have been working on this from some time. Checkout

[https://github.com/daptin/daptin](https://github.com/daptin/daptin)

I have been deferring another show hn since the last one, since I am always in
the middle of adding one more feature :p

my overall goal in daptin is to build something reliable which can run for
years without needing any maintenance. Some things to show this is that its
written in golang and I build static targets for all target hosts, the thing
is open-sourced and licensed to be used without fear.

As for the features, I will try to list some here:

\- YAML/JSON based data declaration

\- CRUD api implementing [https://jsonapi.org/](https://jsonapi.org/)

\- GraphQL api

\- Definable actions, for custom apis

\- Integration to any 3rd party api based on swagger/openapi spec

\- Runs on mysql/postgres/sqlite

For more advance features:

\- SMTP server, IMAP server

\- Self generated cert/ Acme TLS generation support

\- Encrypted columns

\- Asset columns (file/image/binary store)

\- Asset columns backed by cloud storage (like ftp/disk/gdrive/s3/bb and many)

\- Native OAuth/3rd party login support

\- Exposing cloud store folders as static websites

I have built a lot of apps on daptin over some time now and I love that it has
become what I envisioned it to be.

~~~
ComSubVie
That's a great set of features! I'll try it on my next prototype.

Especially the OpenAPI export is great; I had always problems with
automatically generating it (in go/node.js/.net core).

~~~
artpar
Not only openapi export, but you can import openapi/swagger specs and use them
in actions. Effectively third party integrations.

And I forgot to mention table and row level user authentication permissions
and groups.

------
cpursley
React Admin is awesome for simple low code CRUD applications.

[https://marmelab.com/react-admin](https://marmelab.com/react-admin)

Combine React Admin with Hasura (automatic GraphQL on top of PostgreSQL) and
you can build an entire back office admin suite (API endpoints and admin front
end) in a matter of hours.

[https://hasura.io](https://hasura.io)

This adaptor connects react-admin with Hasura:

[https://github.com/Steams/ra-data-hasura-
graphql](https://github.com/Steams/ra-data-hasura-graphql)

Here's a reference application I put together:

[https://github.com/cpursley/react-admin-low-
code](https://github.com/cpursley/react-admin-low-code)

~~~
ajsharp
_blinks eyes_

Wow Hasura + react admin look incredible. Thanks for this.

~~~
elwell
It's a great combo. Been fortunate to be able to use React + Hasura +
Clojure(Script) + Re-Frame at my job; great stack to work with.

------
ksec
If you want No Code solution, AirTable and Coda. On one hand I sort of wish
more business knew about it as it would likely simplify most of their work
load. On the other hand I dont want that to happen as it gives current
businesses advantage.

For Coding Solution, ( Incoming Unpopular opinion ) if you dont mind _modern_
PHP, ( which is a lot better than old PHP) Laravel [1] is to my mind
undoubtedly the king of CRUD framework. The whole ecosystem is, and continue
to be outpacing and growing faster than Rails ecosystem. Which makes me very
envy.

If you dont like PHP, then Ruby Rails.

[1] [https://laravel.com](https://laravel.com)

~~~
40four
I think the hate has gone too far on PHP. I work in Laravel for work, and it
continues to impress me. Such a pleasure!

Also, Laravel collections are amazing. They make working with arrays and
transforming data a breeze.

~~~
aphextron
>I think the hate has gone too far on PHP

It was very well deserved back in the pre-7.0 days, when it was common to have
horrific spaghetti projects with zero structure, global variables/functions
everywhere, and all kinds of logic (including database calls) mixed into view
templates. Modern PHP is a whole different world, but most people will simply
choose something else now because that stigma is impossible to lose, and
finding dedicated PHP developers is increasingly uncommon.

~~~
lmilcin
I disagree. You can't slap on features on a bad language and make it good
language. You can only make it more palatable.

Good languages start good because the people who designed and built them had
good idea of what they wanted to achieve and did not have existing users to
compromise with.

~~~
ComputerGuru
> You can slap on features on a bad language and make it good language.

I believe you meant to say “you _can’t_ ...”

~~~
lmilcin
Yes. That is what happens when you edit your post and then skip proofreading.

------
andybak
If you want a database-backed CRUD with extra business logic then it's hard to
beat the Django admin. You get support for common cases out of the box and
extending/overriding the normal behaviour is fairly straightforward.

It looks fairly presentable and has a non-awful UI. Certainly not state of the
art but good enough for non-public facing stuff.

~~~
1337shadow
For Django, the trick is to implement an MVC pattern: let a class sit in-
between a model and its set of views and pilot the views from there, like the
admin, drf and others.

However, the admin does not leverage the Django ecosystem, django-tables2,
django-filter, and so on. Also, it's kind of moving slowly because they must
try to respect backward compatibility.

I maintain CRUDLFA+ and I love it:

\- lets each view define its own url generation method: the controller will
use that to generate the urls for a model \- each controller defines a
get_queryset method which has a request parameter, allowing you to define what
objects a user may see

\- each view defines a has_perm method, as such a user may see a bunch of
objects, but not necessarily execute all views on it,

\- the default list view wraps django-tables2, django-filter, django-search,
and generates a per-object menu, by iterating over each view of the controller
and testing it with has_perm, as such a user will see an object menu with each
view it can execute on an object, with no overhead

\- allows you to override views in many ways

\- works with non-managed models (models that are not backed with a database
table)

\- can be used for frontend pages too (admin is really limited to being a
back-office),

Clearly, CRUDLFA+ goes beyond "basic crud", but I would never code a Django
view without it ever again though.

However, so far I make it for my personal use and even though it's been in use
on governmental production for a couple of years now, I wouldn't recommend it
for beginners. If you're a Django expert and get your kicks out of trying new
patterns then you might spend some good times with it.

[https://yourlabs.io/oss/yourlabs](https://yourlabs.io/oss/yourlabs)
[https://gitpitch.com/yourlabs/crudlfap](https://gitpitch.com/yourlabs/crudlfap)

We're in the (slow) process of replacing Jinja2 in it with Ryzom (
[https://yourlabs.io/oss/ryzom](https://yourlabs.io/oss/ryzom) ) , a
component-based HTML renderer which supports data-binding and that we are
looking forward to integrate or isomorphic research (from
[https://yourlabs.io/oss/chp](https://yourlabs.io/oss/chp) ) into. When that's
over we will release v1.

~~~
raihansaputra
This is really interesting. Will take a look on how this works for me!

------
Ididntdothis
To me it's still surprising that nobody has done something like MS Access or
VB6 for the web. They were easy to learn but had enough power to create really
complex solutions. The only downside were scaling and multiple user support.
These problems shouldn't be that hard to solve.

~~~
kls
I love access, and pushed it at many jobs that I have been at. Many times you
have small teams who just are not worth the investment of enterprise systems
while they are still growing that part of the business. Access allowed them to
solution their needs while the requirements are still in flux. Once a
department becomes big enough the access solution serves as a working
prototype to generate requirements to build a proper system. It is a shame
that Access has fallen out of favor and there really are no web tools that
compare to how well it enabled users.

~~~
chihuahua
One could argue that Microsoft PowerApps (Dynamics 365 CDS model apps) is the
enterprise equivalent of Access. It's extremely easy to build a CRUD app
without writing any code.

~~~
collyw
Access has always been relatively easy to build an app with close "to no
code". The problem is that you still need to understand the principles of a
relational database to use it properly and that is usually taught after basic
coding.

------
Ozzie_osman
Django admin, with Django rest if you want to easily add APIs.

~~~
Ozzie_osman
Also, pro-tip: host it on Heroku for ease if you're not anticipating a ton of
traffic. Literally minutes to set up and almost no maintenance overhead going
forward.

------
dyeje
Ruby on Rails without a doubt. You can even take it a step further and use
ActiveAdmin.

~~~
tluyben2
I think it is a matter of taste or experience language wise but I would say
Django with the admin.

~~~
auston
Have used both extensively. I like the Django ORM better than ActiveRecord but
love the conventions and magic you get with rails + ActiveAdmin!

~~~
tluyben2
I have used both for years as well and I cannot stand the ‘magic’ ;) Hence my
comment about taste.

------
theptip
I think the meta-answer is to pick the CRUD framework for the language that
you already know well; e.g. if you know Python, use Django. But if you know
PHP already, just use Laravel or whatever, rather than learning Python to get
access to Django.

While there are features in some of these frameworks that will give you a
productivity boost in certain use cases, none of them are worth taking the
productivity hit of learning a new language.

------
sansnomme
For non-web, give the Red programming language a try. Java is also another
good one. I am afraid there just isn't a good, robust, free and open source
system when it comes to client-server stuff. Rapid development tools also tend
to be less mature on Linux, compared to OS X and Windows (Mac and Windows have
a rich tradition of business/enterprise rapid prototyping e.g. FileMaker,
HyperCard, Visual FoxPro). If you are on the Microsoft stack (and don't need
gimmicks like multiple screen size support, Material-style shadows and
animations), the standard WinForms system is also quite productive. I heard
that the new SwiftUI system is starting to bring back the spirit of rapid
development too though I have no tried it myself. These days "no-code" systems
are also making a comeback with half a dozen new SaaSes showing up on HN every
other week.

~~~
9214
Red is cross-platform and works pretty well on distros that support 32-bit
libraries, GTK backend is also fully functional [1], so I don't get why Linux
is excluded from your list.

Red author also plans to port Cheyenne web server at some point after 0.7.0
release. [2]

[1]:
[https://github.com/red/red/tree/GTK](https://github.com/red/red/tree/GTK)

[2]: [https://www.cheyenne-server.org/](https://www.cheyenne-server.org/)

------
gavinray
Hasura and React Admin with Hasura RA data-adapter

[https://github.com/hasura/graphql-engine](https://github.com/hasura/graphql-
engine)

[https://github.com/marmelab/react-admin](https://github.com/marmelab/react-
admin)

[https://github.com/Steams/ra-data-hasura-
graphql](https://github.com/Steams/ra-data-hasura-graphql)

------
maltalex
Haven’t tried it myself, but what about postgrest?
[https://postgrest.org](https://postgrest.org)

------
focom
There is also
[https://github.com/strapi/strapi](https://github.com/strapi/strapi) which is
a CMS for rest api. You only have to write a frontend.

~~~
kostarelo
Have you actually used it in production? I would love to try it but I'm
hesitating in case it's still not ready for a more complicated project.

------
yen223
I've found success using Google Sheets as a backing datastore for some
automation projects of mine. Google Sheets has a rest API that you can use.

------
ollerac
Remake - a server-rendered framework for building CRUD web apps [0]

This is an open-source framework I've been working on for the past year to try
and solve this problem. I was tired of building the same back-end over and
over again and wanted to be able to define my data all in one place.

It works kind of like Vapid[1], in that it allows you to define back-end logic
with front-end syntax. But it goes a step further and has more built-in web
app capabilities like support for each user owning their own application,
nested elements and pages, sorting elements, and inline edit areas.

I just posted a Show HN[2] in another thread. I love for you to read more
about it there. You can also see some code examples and a simple demo
application here:
[https://docs.remaketheweb.com/](https://docs.remaketheweb.com/)

Reach out to me with any questions. I'm always available to talk:
david@remaketheweb.com

[0] [https://remaketheweb.com/](https://remaketheweb.com/)

[1] [https://www.vapid.com/](https://www.vapid.com/)

[2]
[https://news.ycombinator.com/item?id=22092480](https://news.ycombinator.com/item?id=22092480)

~~~
gavinray
Interesting idea, I checked out the site.

One piece of feedback, I had to go into the docs, under (A Simple Example App)
to get a sense for what it was/how exactly it worked.

In place of the video that is the first piece of media content on the landing
page, I would have much preferred some snippet of code and a visualization of
its result. That way as soon as I come to the site, I get a feel for what
exactly it is.

I think this would markedly improve your ability to communicate what Remake
is. As the old adage goes:

 _' Show, don't tell.'_

~~~
mritchie712
either this or a 90 second demo of building something (e.g. how you made the
cards in the demo app)

~~~
ollerac
It's a little longer than 90 seconds, but you can find the full ~40 minute
tutorial for that here: [https://docs.remaketheweb.com/introducing-
remake/](https://docs.remaketheweb.com/introducing-remake/)

I agree, however, something short and sweet showing off the code and how to
build something is sorely needed on the home page. I'll brainstorm about it
and update the page soon.

~~~
mritchie712
you could probably cover most of the todo example in 90 seconds

------
sinnombre
Jhipster if you want to do it in Java. Do check it out if you want a lot of
options. For example angular or react frontend, SQL or nosql, monolith or
microservices. Warning: it relies heavily on spring framework. So that may be
an entry barrier too.

~~~
indecisive_user
I believe jhipster works with kotlin as well.

------
qpiox
OpenXava ([https://openxava.org](https://openxava.org)) is an platform that is
open source and automatically generates user interface based on CRUD
operations (+ much more). Even for one-to-many or many-to-one associations, it
creates look up lists and master-detail user interfaces. It also creates
interface for searching, for printing reports, for custom queries, for group-
by and similar aggregate queries and much more. All automatically.

How? It uses information that you provide which Java class corresponds to
which table, Hibernate style JPA ORM annotated classes, either in XML or as
plain java classes with annotations (one class per table).

If you have a large database, with multitude of tables, you can use the
Hibernate / JBoss reverse engineering tool to generate the mapping classes
directly from the database structure. See this:
[https://eugencovaciq.wordpress.com/2016/02/01/hibernate-
tool...](https://eugencovaciq.wordpress.com/2016/02/01/hibernate-tools-
reverse-engineering-using-maven/)

There are other tools that could help. Why OpenXava? Because it is very easy
to customize the generated user interface and it is very flexible. You just
add @view annotations to the classes that modify how the interface is
generated. For example, when you need to drop out some attributes, or not show
a link to another table, or when the table is used as a lookup for the foreign
key in another table, you can configure how the lookup will look like in one
situation, and how in another. You can reconfigure the layout of complicated
forms for tables with many attributes, also using view annotations.

I am not involved with OpenXava, but have used it to make an administration
interface for several apps. I have a maven script that can be run from the
command line, that uses hibernate reverse engineering library to generate the
mapping classes and i have the initial app in minutes.

------
erikcw
We’ve been using Anvil for internal employee tools for the last year or so
with much success.

[https://anvil.works/](https://anvil.works/)

------
rumanator
For those like me who never heard the term "CRUD screen":

[https://wiki.c2.com/?CrudScreen](https://wiki.c2.com/?CrudScreen)

------
aosaigh
Are you looking for a framework or a more complete tool? Django or Ruby are
good for putting together CRUD tools very quickly. If you make use of their
ecosystem of libraries you'll be able to put a Bootstrap CRUD app together in
no time (assuming you have webdev experience).

------
seagull
[https://tryretool.com](https://tryretool.com) (YC W17) is great for this use
case.

------
tluyben2
There are a lot of nocode/lowcode tools with batteries included if you do not
mind paying a monthly fee (although some do not even require that; only a one-
off fee). Airtable, Bubble and many others make it really easy to create CRUD
apps. There are also open source solutions (I did not try so no idea how good
they are) like [0].

[0]
[https://garrylachman.github.io/ElectroCRUD/](https://garrylachman.github.io/ElectroCRUD/)

------
jtwaleson
Low-code solutions are great for this. I worked at Mendix in the past, which I
still really like. Competitors are outsystems, Google appmaker, Microsoft
powerapps and more.

------
haddr
I wonder if there is something for CRUD as easy as Delphi used to be for rapid
prototyping.

------
alharith
The tool you are already the most familiar with will most likely be the
fastest. Every new tool has a non-zero upfront learning cost.

~~~
collyw
Counterpoint, I started using SQLite with Python and after less than a day of
writing SQL manually I decided just to learn SQLAlchemy. Its cut the amount of
code down a lot and the learning time has paid itself back quite quickly.

------
PaywallBuster
If you're confortable with Laravel PHP, check out
[https://backpackforlaravel.com/](https://backpackforlaravel.com/).

I've used it for a couple of projects over the last few years.

The OSS project has really gone a long way since the earlier days (it was
actually called Dick).

Seems to be quite popular too:

500.000+ downloads

14.000+ developers use Backpack every month

------
vlasky
Grocery CRUD is a CodeIgniter/PHP library that lets you quickly create a CRUD
with views. Officially it only supports MySQL but some third-party patches let
you use it with other databases.

[https://www.grocerycrud.com/](https://www.grocerycrud.com/)

------
markhalonen
Postgraphile
[https://github.com/graphile/postgraphile](https://github.com/graphile/postgraphile)

It's like Hasura but written in a language you can understand.

Using it with great success on two projects, both > 3 months into development
on.

~~~
lucas_membrane
If such long projects, I guess the benefit must be a pretty high quality
system to earn your praise. Can you describe the benefits?

------
pablobico
We just released our visual code-generator:
[https://www.generato.com/](https://www.generato.com/) or
[https://app.generato.com/](https://app.generato.com/)

We have built a technological graph to set up your applications in seconds
instead of hours, days or even months. You could than apply text-based
templates (with placeholders) and generate (and update) out of the browser or
our desktop-applications. Individual added code stays where it is!

Currently we support CRUD, Authentication for Java, PostgreSQL and Angular for
free, but we are expanding our template-stack and even you as our user are
free to integrate your own technology.

We are in a free beta-stage now, so give it a try!

------
jamesfmilne
Try Xojo for a cross-platform modern VB equivalent.

They can compile to a webapp now too that presents the UI in a browser.

[http://www.xojo.com/](http://www.xojo.com/)

Disclaimer: I worked on Xojo’s earlier incarnation REALbasic waaaaay back.

------
mister_hn
API-Platform is a OpenAPI-based project that helps you focus on the business
logic of your project, because the CRUD will be easily generated:

[https://api-platform.com/](https://api-platform.com/)

------
Saphyel
Look for api platform ( [https://github.com/api-platform/api-
platform](https://github.com/api-platform/api-platform) ) otherwise flask rest
api is another great option

------
camkego
You shouldn't overlook Orbeon Forms, it has history going back to 2007 (it
seems quite mature). I believe it can just be used like a robust black box to
do both CRUD and HTTP web front ends.

~~~
avernet
Yes, Form Builder, in Orbeon Forms, allows you to create a page with form
fields, use the provided values to call a REST/CRUD API, and show the result
on that page. You can try that out for yourself on demo.orbeon.com, or
download the software and run it locally.

There is an open source (LGPL) Community Edition, but the services & actions
feature you need for this is only available in the Professional Edition. This
being said, if you just need this for your own local testing, you can get a
trial license (automatic process, valid 3 months, no limit on number of
licenses you get), and have fun with it.

Bias: I'm one of the Orbeon Forms developers ;). ‑Alex

------
eugeniox
DaDaBIK ([https://dadabik.com](https://dadabik.com)) is a no-code low-code
platform that can generate a Web CRUD app in minutes starting from your
existing DB (but you can also design the DB in DaDaBIK itself).

It has been around since 2001, CRUD generation has been its main aim since the
beginning, with the last versions you can also generate very complex
applications injecting some custom code (php, javascript) to implement your
business logic.

Disclaimer: I am the founder.

------
la_fayette
If you are looking for something proven I would use django. It is easy to add
new models and generate crud-UIs with django-admin. Django has many useful
modules for extension.

~~~
collyw
Django's migrations are a nice way to take care of database changes. The NoSQL
crowd should try this out before ranting about the benefits of "schemaless".

------
zikani_03
Try CakePHP. The `bake` tool allows you to create CRUD functionality quickly.
Just create your database and run `bin/cake bake all` and it creates
everything from models, controllers, views (templates) and even tests!

I have been using it since 1.3.x days and it's just got better over the years
- migration between versions was relatively painless.

[https://cakephp.org](https://cakephp.org)

------
oblib
PouchDB.js.

PouchDB is, in my opinion, an overlooked gem that deserves more attention.

For small tools you don't even need a backend. It uses your web browser's
built-in DB

~~~
lucas_membrane
What are the limits (per app, per user, per browser install) for amount of
data, number of rows, etc in browser built-in DB's nowadays?

~~~
oblib
I really don't know the answers to that, but I did do a bit of testing on my
old Mac Mini (late 2009, 8GB ram).

I wrote a script that created 1000 documents that were pretty small just a few
k at most.

The app I wrote using pouchdb to use find and edit them started choking when
Safari had about 5000 documents stored in it.

If you install CouchDB on your local box, or a remote server, and configure
PouchDB to use your CouchDB to store and access those docs you can probably
have 10s of 1000s and I know you can scale that up to millions of documents
with the right hardware.

You can get industrial strength remote CouchDBs from IBM and CouchBase for a
pretty reasonable fee too. And you can run PouchDB with Node,js on a server
and store your docs on it. So there are a lot of ways to use it.

------
brandly
I've liked using Parse.

[https://parseplatform.org/](https://parseplatform.org/)

------
serverQuestion
ruby on rails?

------
collyw
If its for internal use then Django's admin interface is pretty good. It's
limited in some aspects (you will need to login to use it) so better suited to
internal use than public facing websites, but for many tasks it's amazing.

------
kohtatsu
This meta-tool was posted 2 days ago, JSON w/ queries -> admin pages.

[https://news.ycombinator.com/item?id=22073037](https://news.ycombinator.com/item?id=22073037)

------
jonotime
There is always swagger codegen, which I have not used in a while. I believe
you just give it your json swagger spec and it can generate server stubs of
about 20 or so different languages/frameworks.

------
m_abdelfattah
Ruby on Rails' Active Admin is my favorite
[https://activeadmin.info](https://activeadmin.info)

------
escape42
Just do an AWS API Gateway to DynamoDB serverless integration, free CRUD, no
need to implement the individual operations manually.

~~~
scarface74
But then you’re stuck with DynamoDB. DDB is only suitable if you have a well
defined access pattern.

I’m all in on AWS, but I wouldn’t recommend APIGW/DDB as a general purpose
solution.

------
omani
[https://postgrest.org/](https://postgrest.org/)

------
pier25
On the server check Hasura. You get a GraphQL CRUD over Postgres in almost one
click.

------
altmind
rails and activeadmin. define models, include a gem and you got basic crud
admin interface.

------
popup21
Pencil and paper

~~~
aliswe
Care to elaborate?

