I always thought the most clever thing that could be done in this app category, would be to design and standardize a microformat for presentation customizations, that could be written into the SQL-standard “comment” metadata field that’s attached to almost every SQL-standard DDL object (tables, views, procedures, triggers, etc.)
Then, admin panels could all interoperate in terms of showing e.g. “pretty” names for things; and could also pick up presentation metadata burned into the DB’s objects at creation time (by e.g. your app's DB migration logic), even if the admin panel is not able to change the data itself.
(Of course, you could use something like this for more than presentation metadata; you could use it to encode type-binding hints for particular ORMs, for example. Think of it as the equivalent of the old macOS “resource fork” for the object — an unstructured thing that could be informally structured into a sort of user xattrs storage if people are willing to cooperate.)
Ages ago there was a company trying to do this kind of auto-discoverable UI through their proprietary protocol for controlling and monitoring audio/video processing equipment. It seems like it should be possible, but for some reason hasn't caught on yet in any industries I'm aware of.
My own personal comparison would be to how many Helm charts for various Kubernetes resources bundle Prometheus-metrics endpoint resources, and Grafana-dashboard definition resources alongside them; such that if you're using the k8s-resource-aware Grafana (e.g. the one in the Prometheus operator), it'll pick those declared dashboards up automatically and show you the metrics for the thing you're running.
In this case, the "Helm chart" is an app like Wordpress that runs DB migrations; the "monitoring resources" it deploys are the SQL-comment microformat data created by those migrations; and "Grafana" here is the DB admin panel, taught to look for that data.
Last year I've been searching for some administration engine for my Rails side project and I was not able to find a suitable option.
I hate writing a ton of custom code for internal admin/tools so I decided to write even more code to build a general-purpose, no-code Motor Admin
Motor Admin allows to convert raw data into a powerful admin panel to cover almost every operation needed for most businesses.
Features:
- CRUD out of the box with many customization options
- Custom data reports with SQL
- Business intelligence dashboards with fields and variables
- Forms builder for custom workflows to integrate with API
- Report alerts via Email or Slack
- User roles and permissions
- Audit log
- English, Spanish, Portuguese UI languages
- Works nicely on mobile screens
Motor Admin is distributed as a single executable binary - it can be easily self-hosted on Heroku or via Docker. Also, it's possible to try it locally with binaries for macOS and Ubuntu Linux.
Would be glad to receive any feedback or answer any questions regarding the project.
Thanks for building this! It seems to cover most features I'd want.
The Dockerfile is simply downloading a release from GitHub. Docker Compose file is referring to an existing image on DockerHub. How can I build a Docker image for myself starting from the code?
What I meant to ask is: Why is the Dockerfile that generates https://hub.docker.com/r/motoradmin/motoradmin not available in the repo? It makes it hard to verify exactly what went into the image or to dockerize on my own. I don't see any instructions for building the binary executable either.
This simply downloads a 65MB binary executable "motor-admin-Linux-x86_64" from GitHub and does not build from the code given in the repo. There's no visibility into what the binary actually contains or how to build it on my own.
I'm excited to try and yet can't seem to get it working.
I followed the steps to install it on MacOS from the GitHub page and I'm thinking maybe I ran the curl command from the wrong directory, as when I try to run ./motor-admin, it gives two dlyd errors:
1) "lazy symbol binding failed: Symbol not found: ___darwin_check_fd_set_overflow"
2) "Symbol not found: ___darwin_check_fd_set_overflow"
And it shows the "Referenced from:" being my current directory, somewhere in my Documents folder, and then "Expected in: /usr/lib/libSystem.B.dylib"
Ahh, I think I may have the opposite problem: I'm on Mojave and I think I need a newer version of Xcode but can't update it because I'm still on Mojave :-)
This looks awesome. How difficult would you estimate migrating from ActiveAdmin to Motor? (beyond CRUD stuff ideally... i.e. we have quite a bit of custom code into various actions, screens etc)
ActiveAdmin serves us well, although shows its age, and recently it feels a bit abandoned (don't want to say anything bad, it's a tremendous piece of open source and we got a ton of value from it).
It's hard to say how difficult it could be but some companies already migrated from activeadmin to motor admin gem for their rails projects and they claim that it was worth it :)
Thanks, it's possible to contribute into https://github.com/motor-admin/motor-admin-rails it's a ruby gem which powers motor admin app - support for new data sources and more data visualization options (cohort) are welcomed :)
The biggest difference is that Motor Admin has a convenient self-hosted option with a single click deploy.
Self-hosted comes with many benefits like custom domain, ability to host under VPN, and faster UI due to lower network roundtrip and CORS avoidance.
Also, Motor Admin open-source version has powerful business intelligence features with custom SQL reports, BI dashboards with variables and fields, and automated email reports.
Also Motor Admin's UI is optimized on mobile and the UI is faster in general.
In terms of available features open-source, self-hosted Motor Admin could become a much better option than ForestAdmin SaaS for an admin interface.
Internal.io does something similar and supports SQL Server (as well as MySql, Postgres, Snowflake, DynamoDB, MongoDB and more..).
It's a bit more like Retool with the visual builder but easier to use without code. Comparison vid with Retool here: https://www.youtube.com/watch?v=7GgBnbHF8Rg
Full disclosure: I currently work for Internal but if you have any questions on our platform let me know!
I see a few comments asking about supported database backends, suggesting they understand how Motor Admin works. From reading the website and the github Readme, I still don't know how it works. Surely it must connect directly to my database, but I couldn't find anything to actually confirm that. It just tells me how to run a binary or docker image. I'm sure I missed something, but I thought this information would be obvious.
Thanks that's a good point.
It requires to connect to the database (postgresql or mysql) and the tool automatically build an admin UI on top of the existing data.
You can try it yourself locally on macOS, Ubuntu or in docker if you're on windows:
I can't figure out how self-hosted and "deploy on cloud" are not mutually exclusive. Unless you've gone through the trouble of setting up enough machines at home to have a viable cloud infrastructure.
"self-hosted" just means you host it yourself. Where and how is up to you, but the instance is entirely in your control.
"Deploy to cloud" is just an answer to the "where and how"
- a singular option.
This is (typically, though not always) different from SaaS and on-prem, the former being hosted/managed/monitored by a third party, and the latter meaning hosted by you, usually managed and monitored by a third party - often for regulatory or whitelabelling reasons.
I kind of know that's what it's taken to mean, I entirely disagree though. If it's not your hardware, on your property, you're not self-hosting, you're renting.
My team has been using Motor for almost six months now, on a greenfield project at an early stage startup, and it has been absolutely phenomenal. It does everything we need it to, saves us loads of dev time, and has been intuitive for our non-technical folks to work with. We’ve also been able to easily extend it for our specific use cases. It’s a very well-designed piece of software.
The handful of times we’ve experienced issues, Pete has been quick to step in and help, usually publishing a fix within hours.
After my startup failed and I found myself with a bunch of admin panel code I thought of building something like this but the number of competitors (both paid like retool, forest or OSS rails-admin, keybase) always deterred me.
Building your own is not what makes or break a startup: small startup would love this but they would not want to spend the money and just deal with things manually, building only what they need; bigger companies already have their system in place, built slowly over the years.
I'd be curious to know how you're planning to sell this.
Thanks, yeah I hope new/small startups could find this tool useful. Large companies could also use it to manage some part of their business while keeping their old admin UI in place.
Nice work. I've been exploring an idea in the same space with a very different angle.
You need other, non-technical users at a company to use this type of tool for it to be useful and it's really tough to get a team to adopt a new tool. My solution? Build it on top of something they're already using: Google Sheets.
Not ready for a formal launch, but would love to chat with anyone that wants to try it out: https://www.wax.run/
Interesting idea, though I am somewhat skeptical on the business model. Users building something that complex over spreadsheets are probably the "shadow IT" types, so how does one get their company to pay for this without getting roadblocked?
They'd be shadow IT at a larger company, but it's not as frowned upon at smaller companies. They're generally more concerned with getting shit done than doing it "the right way".
It's at a price point most people at a startup can put it on their corporate card without question. But yes, it's tough to get a fortune 500 to go for something like this.
Wow the demo video looks amazing. I'm a programmer, but coding that would take much longer than those few clicks.
I wonder if you could use a "standard" REST backend as a data source?
You lose the ability to use raw SQL queries, but then you could use this for any API and use the full CRUD with whatever actions and safeguards the server has programmed.
Specifically, I'm thinking about feathersjs with it's hooks instead of just accessing the database directly.
Currently it's not possible to use REST backend - direct database connection is required for motor admin to build internal rest json-api on top of the database to power the admin UI.
My concern is that with REST backend it would become a much complex tool and will make it harder to build an admin panel - Retool does a good job building internal tools with visual builders and connecting APIs - but that definitively takes more time to build admin panel with it than with Motor Admin.
This looks _fantastic_. I've sort of wanted these features in Metabase, but alas, it's really more of a BI tool. Audit log and custom forms are amazing. It'd be really cool if you could build reactive state based on custom forms. Almost like a no-code/low-code event sourcing system
This is awesome. Is there any way to add custom hooks to a create/update/delete operation? For example, I want to call run a script or program every time a user is created; for example to add that user to an LDAP directory or remote server.
It's possible to override default CRUD with custom actions/forms and so all additional data processing will be handled on the product back end API side.
So let's say to want to add user to some LDAP directory once the user is created in Motor Admin.
In order to do that you need to override the default user creation form and send data from that form to your API back end so you can handle user creation in LDAP from there:
https://monosnap.com/file/3CD1qKgNoTBOhwTwzLiNJXTUNgi8yH
All those API requests are sent with JWT header - so it's possible to validate them on the back end.
Thanks, proper documentation will come really soon.
All configurations are stored in motor.yml file which is automatically generated in root directory.
There might be two ways handling configurations:
1. Use git to create commits with new configurations in motor.yml and deploy/pull that git repo on the production host in order to update the configs.
2. rake motor:sync to sync configurations directly to production app host via API.
There a bit of info about configurations sync between environment here:
I see a lot of people are doing similar projects, so it's clear that demand for ability to easily create apps for data management are on rise.
I've stumbled upon this too, tried over time many web frameworks and tools like retool, and I had two biggest complaints: a) there is no one-size-fits-all solution; b) web stack sucks.
A) The classic dilemma of using general-purpose solution vs custom-tailored solution. Creating admin panel with 3 screens with basic CRUD functionality should be a no brainer in 2021, but the complexity of underlying stack is so high, that there is virtually no choice except of using general purpose solutions.
To be clear, I'm talking about "I should be able to make such an app alone in couple of hours max" essential complexity levels.
B) Web is based on 3 pillars – HTML/JS/CSS, and I don't know how we ended up here, but those components were okay for linked text documents in 90s. They have never been designed for making modern reliable UI apps, and they are really bad design choices if we were building fullstack framework nowadays from scratch. No amount of complexity stuffed on top of this can solve the underlying nature of browser's stack. In short, it sucks at the fundamental level. And as more and more generations of programmers start their careers in the web world, objections to those stack choices are not answered, because they are no longer even raised.
Personally I find it hard to maintain projects I did with all possible web frameworks after a year or so. And the amount of security issues, amount of accidental complexity it brings to the development framework and the ever growing frustration with the technical limitations of this stack makes me invest a lot into abandoning this "modern web stack".
Plus, after 20+ years of writing SQL, I still find it suboptimal language for interaction with DB, and it contributes to the slowdown of development (and the need for general purpose solutions) too.
---
So, instead of doing yet another framework, I decided to go the different path for my projects. First, I rethink the stack from the ground up and choose tech with the least amount of accidental complexity and cognitive overhead. Second, I do template the typical CRUD functionality, so I can quickly create new admin-like project and add new screens/entities (while keeping it independent source from the tool that generates the code).
My current stack now is EdgeDB+Go+gRPC+Flutter.
- EdgeDB has fantastic tooling and decades of PostgreSQL engine reliability under the hood, but the real magic for me is in their query language – you don't want to return to SQL ever again after EdgeQL.
- Go – no comments, easy to write, easy to read, extremely fast (I almost never have to scale server for performance reasons) and the code I wrote 6 years ago works and compiles today and easy to maintain.
- gRPC solves the single point of truth for API, serialization/deserialization and other API things, that has never been in the original thought of the typical JSON/REST/HTTP stack. It's super mature and saves me a lot of time in the syncing backend and frontend API code.
- Flutter is a game changer many people not aware about. I write admin and user facing code in Flutter for almost 3 years now (2 of them using their Flutter for Web), and it's just insanely good. In one go I get native iOS/Android/Windows/Mac/Linux and Web apps that are indistinguishable in the look and feel. The best thing that happen in UI development in the last 20 years, as for me (I've made Qt apps in the early 2000, and Qt was the previous best thing). I also develop my own admin UI library for my typical apps, that has all the "must have" features and design.
So with this stack in mind, I simple wrote a command line tool in Go that does initial bootstrapping for new projects and adds new entities to the app with predefined templates (db schema, db code, conversion code, grpc handlers implementation, protobuf, flutter screens and API code). It takes around 2 seconds to generate a new screen given the fields definition. I then modify generated code as much as I want, not being "tied" to the tool. There is not a single line of JS/HTML/CSS there too, which is fantastic.
I'm still polishing the tool and admin UI lib, and it's not opensource yet, but I can't describe how great it feels to have this tool in my toolkit. Some apps built with it are already in production (including web apps) and work amazingly, and I'm mostly working solo on them.
Interesting, you use EdgeDB but not GraphQL instead of gRPC? I looked in to EdgeDB and GraphQL seems to be a big part of it.
With gRPC and UI side of things I think there is some issues, like no standard way to handle validation errors (e.g. email field has incorrect value), so everyone reinvents the wheel.
Edit: Also this EdgeQL seems like nice way to interact also from UI. gRPC is not mentioned in the EdgeDB at all.
Yes, EdgeDB has native GraphQL layer, but I'm not sure I need it. I still want to have a precise control over the the communication, memory usage and DB performance, plus as soon as you add new functionality on top of basic CRUD, it's not enough to talk directly from frontend to DB anymore.
I'm not sure if those are my biases, but I still try to keep things into separated layers (i.e. DB, backend, communication and frontend), so I can change them without affecting the overall design too much.
Motor Admin generates json-rest API under the hood on top of the database - I might be wrong but I don't know any good use case where Graphql API server as a proxy between the data and the admin UI could be useful.
> I don't know any good use case where Graphql API server as a proxy between the data and the admin UI
If you want a view that consists of multiple entities. Example: a view that displays a customer with his last 5 orders and current inventory count for the items in those orders. That's probably 3 entities (customer, orders, inventory). Sure, you can do this with REST but typically it will require calls to 3 different endpoints to gather that data. A graphQL server can serve the same data with 1 endpoint using a custom graphQL query. I'm not saying one is better than the other; just trying to give you an example.
Personally, I think that Graphql is overcomplicated and Facebook marketing efforts did a pretty good job for its adoption by developers and companies.
The example you mentioned can be easily implemented in Motor Admin via SQL queries or admin UI configurations with direct connection to the database and the performance would be probably better than it could have been with Graphsql.
AppSmith is aimed more on building UIs when Motor Admin has a single unified admin UI which can be configured and extended via simple configurations without visual builders.
Due to this approach it should be much easier to build admin panels using Motor Admin.
Can you run javascript like appsmith does in its widgets fields? From Dashboards can you create live polling / refreshing panels to show stats updating real time something like that?
The question is - do you actually need to run javascript to build an admin interface for your company?
With Motor Admin you don't need to - you can achieve almost everything AppSmith/Retool does with simpler configurations using the unified motor admin UI.
Then, admin panels could all interoperate in terms of showing e.g. “pretty” names for things; and could also pick up presentation metadata burned into the DB’s objects at creation time (by e.g. your app's DB migration logic), even if the admin panel is not able to change the data itself.
(Of course, you could use something like this for more than presentation metadata; you could use it to encode type-binding hints for particular ORMs, for example. Think of it as the equivalent of the old macOS “resource fork” for the object — an unstructured thing that could be informally structured into a sort of user xattrs storage if people are willing to cooperate.)