While my initial thought was to build a simple Django application, I'd prefer something non-developers could also work with. -> Low-/No-Code Solution
While I'm generally willing to pay, I'd really prefer an open and self-hosted solution.
GitHub link: https://github.com/appsmithorg/appsmith
I am going through the "Create Standup Application" tutorial.
Did u use a specific library to add the hints/popups or is it all manually patched in?
Do you plan to include GraphQL queries ?
I keep hoping that there’s ways to make low-code work without those drawbacks, and plan to try some new ones I see in this thread. In my mind it has to be a designer that a “non technical” uses to output quality code that a dev can then tweak, but not break the designer.
I think for one-off projects and workflows that aren't deeply integrated, tools like Node-RED are very interesting and something I'd definitely consider pursuing. But outside of modeling, BPM tools have been more of an obstacle than anything else.
There is a middle ground, and that’s why low code / no code is so popular. Often a business does not need the full flexibility and nonsense that comes along with something like that.
Horses for courses. If off the shelf drag and drop helps you build enough to get your idea up and running and start using it / making money, then that’s far better than being lost neck deep in a code pile and not getting up and running. Once you’ve got the funds, then look at transitioning.
It seems to be a case of 'right-tool-right-job' rather than a blanket rule that no-code is good/bad.
I actually think no-code is incredibly powerful when applied by the right person to the correct problem, and will run circles around a custom-developed app in terms of cost, time and flexibility. If you apply it to the wrong problem then of course you aren't going to get the same outcome, like with any technology. I think the mistake people often make is thinking that no-code aims to eliminate all-code, but like any development tool it just fits a certain niche well.
However they did manage to add RPA to PowerApps, which is a plus.
You should definitively check Metabase [0] then: it's open source, very easy to self-host, and democratize data access inside your team. We started using it for the same reason 3 years ago, I cannot recommend it more.
That allows you to start with next to no code, but you can easily add a little business logic anywhere you need it eventually, and it provides a way to long term transition to a true application if the need arises.
Throwaway for obvious reasons.
This will take a few minutes to implement and be significantly more stable and full-featured than any low/no-code solution.
How does one get started with Django Admin?
Would this tutorial be a good start? https://first-django-admin.readthedocs.io/
https://adsharma.github.io/flattools-programs/
In short, django models are written using a very low level of abstraction. I much prefer dataclasses generated from a high level IDL.
The blog post compares different IDLs and argues why flatbuffer IDL is more suitable.
In order to express queries over such models:
https://github.com/oxan/djangorestframework-dataclasses/issu...
on how this could work. The author wasn't interested, but I might pursue it in a fork.
Is English your native language?
https://nocode.tech/category/internal-tools https://www.nocode.tech/category/app-builders
Lists include both SaaS and self-hosted options
I just set it up this morning in my homelab, and it was very simple to set up.
Coming from building admin tools in ruby on rails previously, this is incredibly easy and straightforward. If I have the money to pay for retool I don't think I would choose another tool in the future
It's even possible to host it yourself which allows highly regulated industries to use it.
Spending over a decade programming makes it extremely difficult to reason about the the precise level of "okay, I can do this" from a semi-technical perspective.
However, once the data is wired up, getting it wired to the various components was pretty straight forward.
It should be fairly easy to pick up for end users. But only if you don’t use denormalized tables. If your DB is in 2/3NF you’ll run into issues, e.g. the ever so useful DataTable cannot update data across table.
Also, there’s a pretty significant hard limit on 500 rows.
PowerApps is a great tool, but be aware of its limitations and see if that works for you.
We are currently working on SQL support and should have the first SQL connectors out next week. Please give me a shout if we can be of any assistance! gvw [at] lowdefy.com
[0] - https://lowdefy.com
Also it seamlessly integrate with existing CI tools and you can use your favourite text editor to create apps, develop templates. Since the Lowdefy apps is purely defined as JSON, or YAML, you can easily write scripts to mange and maintain multiple or larger applications. For example this is how we generate the Lowdefy docs form json-schema definitions.
We also implemented OpenID Connect support so you can "bring your own" auth service. Will be making a post again when these new features ship in the very near future.
Hope you give it a shot! And let us know if we can help!
That aside, here are some lesser known low-code data-frontends:
https://www.basedash.com/ (mysql)
https://www.stackerhq.com/ (airtable)
https://www.glideapps.com/ (sheets)
Alternatively, FileMaker still exists, including a direct web interface option.
I often find that if you truly want a 'low-code/no-code' thing, you're stuck with no-logic no-interaction software. As soon as you start adding logic, you're essentially migrating from programming in a somewhat re-usable language into 'programming' in the form of pictures and application-specific interfaces, which essentially requires the same effort but is much less reusable.
Unless the 'thing' is really a 'table' with some CRUD operations you're gonna en up in a messy situation where some undocumented macro-filled spreadsheet becomes a lynchpin.
I think this used to be the case but the landscape is changing quickly. Deepnote[0], for example, looks like a really interesting programming interface that's not quite traditional programming and lowers the barrier to entry significantly and is (arguably) in the low-code space.
Low-code products for data engineering show that we're not too far away from these sorts of solutions in a more generalized offering. Spreadsheets aren't the only answer.
[0] - https://deepnote.com/
I think better examples might be Databricks, Tecton, H20.ai, or Domino Data Lab. These aim to provide "drag-n-drop"/no-code implementations for the "boring" infrastructure related work in most typical data engineering/analytics applications, while offering a set of tools for more sophisticated uses (e.g. the ability to supply one's own python functions for ayptical or custom data engineering).
Even these fall short, in my view: they're more like platforms on which to build a data science/ML infrastructure--which requires a substantial amount of engineering effort.
In some cases it might be beneficial for some people to 'program' using pictures and arrows etc, but if you're in a situation where you need some complex process modelled and automated, the complexity doesn't just 'go away' because a vendor said 'low/no code!'.
Because phpmyadmin would be too easy. It looks like this OP needs some busywork.
There's also UI tools provided by the first parties that do these things.
APEX was created to replace Forms, which really proved itself as stable technology with some apps having a 30 years lifespan now (code quality and performance aside). but APEX has not even neared Forms in terms of speed of dev. fortunately or not - Forms is so-90-ies and quite discontinued.
...should you mention APEX, then perhaps you should also note MS Access as is pretty much the same.
Some features that are especially important if you're giving access to non-technical team members:
- Edit history of all changes made through the tool
- Permission system to limit access to certain databases/tables
- Views that let you pre-filter tables and hide columns
- Request edit system so that all edits have to be approved (WIP)
We support both MySQL and PostgreSQL, planning to add support for NoSQL databases in the future.
It's paid for teams but free for 2 users.
Website link: https://www.basedash.com
if that's what you want you might want to look into that.
Thanks for sharing.
It doesn't automatically detect foreign keys and make the fields for them correctly. Furthermore, it seems like they don't even use foreign keys for the models created through their UI - I checked the github issues, it seems like all of this is planned but work on it seems to have just started.
Full Disclosure: I worked at Frappe for the last 2 years
It gives you a spreadsheet UI on top of your tables that can be edited directly. All edits are baked into a transaction so when you hit save the transaction is committed. We’ve had a lot of success using it with developers and non-technical product managers designers.
We have a feature called Forms[0] which is pretty spot on for what OP mentioned. Happy to show you (or anyone else) around the product. I'm mike@seekwell.io
Also worth noting we have a simple way to two way sync data between Google Sheets and a SQL database[1]. This turns Sheets into a UI for your database. Works really well for teams that are already using Sheets and turn
0 - https://doc.seekwell.io/forms 1 - https://doc.seekwell.io/syncsheet
- Strapi (https://github.com/strapi/strapi)
- Directus (https://github.com/directus/directus)
- React Admin (https://github.com/marmelab/react-admin)
- Netlify CMS - a bit off the mark but maybe worth considering (https://github.com/netlify/netlify-cms)
Majority of Superset users use the no-code Explore UI in Superset to create charts.
We recently wrote about the big 1.0 release here (https://preset.io/blog/2021-01-18-superset-1-0/)
Also worth noting we have a simple way to two way sync data between Google Sheets and a SQL database[1]. This turns Sheets into a UI for your database. Works really well for teams that are already using Sheets and turn
0 - https://doc.seekwell.io/forms 1 - https://doc.seekwell.io/syncsheet
Would love to get in touch if this works for you.
My general rule of thumb for such tools is that the easy things should be easy and the hard things should be possible.
In case you're interested, these are all the products/resources given so far:
https://adsharma.github.io/flattools-programs/
https://adsharma.github.io/fquery/
https://django-sql-explorer.readthedocs.io
https://docs.djangoproject.com/en/3.1/intro/tutorial02
https://first-django-admin.readthedocs.io/
https://github.com/appsmithorg/appsmith
https://github.com/directus/directus
https://github.com/marmelab/react-admin
https://github.com/metabase/metabase
https://github.com/netlify/netlify-cms
https://github.com/oxan/djangorestframework-dataclasses
https://github.com/priyank-purohit/PostGUI
https://github.com/shannah/xataface
https://github.com/skorokithakis/django-project-template
https://github.com/strapi/strapi
https://hypermachine.substack.com
https://metacpan.org/pod/CGI::FormBuilder
https://powerapps.microsoft.com
Haven't used it myself either, but have also heard good things.
“ A React web application to query and share any PostgreSQL database”
Highly visual, great for people who have difficulties finding curly braces and the semicolon on their keyboards ;)
Your data is hosted in an Airtable or Google Sheet that you control, not in a SQL database, though I'd say this is actually a huge advantage for your goal of a no-code CRUD web app that non-developers can work with easily. It is paid.
Disclosure: I work at Stacker, and we're a YC company. Email in my profile if you have any questions.
Your product looks interesting but I don’t see how it fits the requirements here.
It's a really powerful option for non developers to manage data without having to use SQL / a PG client etc.
1. Up and running immediately.
2. Generate 99% of the code if you don't care about styling.
3. The small portion of your site where you need something more complex is simple Ruby code instead of spending months reading No-Code documentation.