What I'm using now instead of Rebol, part 2

This is just a continuation of the previous topic - that one was getting too long to handle as on single web page. Another solution similar to the database portion of Baserow and NocoDB is Teable: https://github.com/teableio/teable There's a 1 million row demo here: https://app.teable.io/share/shrVgdLiOvNQABtW0yX/view It can work with both Postgres and SQLite, it provides an interface to SQL select access, it has built-in charts, workspace and trash can features similar to those in Baserow, and all the common views for free (Grid, Form, Kanban, Gallery, Calendar). It doesn't include any app builder like those in Baserow, Budibase, or NocoBase. It doesn't connect to as many database as NocoDB, Budibase, r NocoBase, and it doesn't provide web hook automations like those in the other systems (yet- that's one their near future road map). It's among the lighter weight choices of these similar tool, with resource use in between that of NocoDB (best) and NocoBase (next base), requiring a small fraction of RAM required by Baserow and Budibase - and it's very performant, even on low powered VPS.

For my own work, I've been using Flask for just about everything lately. The benefits of using bigger frameworks like Anvil, with lots of built-in visual and productivity-enhancing tools are quickly disappearing, thanks to the productivity benefits of generative AI. Flask is particularly lightweight, powerful, well-known, and it has a great ecosystem. Using generative AI to build UIs with Bootstrap and jQuery in Flask templates beats the productivity of any visual builder - and when you build your apps entirely with code, your AI model can see how your database schema (I typically use SQLAlchemy) and all your logic is connected. Every big AI model is fantastically proficient with that collection of tools: Flask and its ecosystem (Flask SQLAlchemy for database, Flask Login for auth, Flask Admin for instant CRUD grids, Flask SocketIO for real-time features, etc.), Bootstrap, jQuery, etc. NocoDB and Budibase can be connected to virtually any database created by SQLAlchemy, in any common RDBMS (and vice-versa), so that enables all the most important no-code involvement which I'm finding dramatically improves the development process and enables end-user stakeholders in projects. I expect that simple Flask stack, with NocoDB tacked on whenever it's helpful to enable and involve end-users, will be my go-to tools for just about every project I take on going forward. Budibase has more no-code capabilities, including the most complete app builder and automation tools (but with limited users (20) in the open source version), so I don't know how often I'll find it as useful. Baserow still provides the most practical mix of power and simplicity, for both the database and app builder, for projects that will be centered almost entirely around no-code capabilities for end-users. And I'll still likely use Flask to extend it's capabilities as needed. I like NocoBase's app builder features a *lot, but it's more complicated than Baserow, can't build publicly accessible sites, and you need to pay for some potentially useful features (synced connections with existing RDBMS sources, for example). It's more complicated for end-users to master, and not as powerful as pure code tools, so I expect it may be less likely for me to use it for projects - I'm still curious to see if it will find a fit in my work. For projects that need more performance, there are are plenty of alternatives to Flask, such as FastAPI and Tornado. And there dead simple alternatives like Bottle and even Microdot for Micropython (and normal Python), which are basically drop-in replacements for all the basic features of Flask. This set of tools is hard to beat, even for the biggest public facing projects. And with generative AI, tools like Flask+Bootstrap+jQuery (or choose React, Vue, etc.) are now tremendously productive to build with.

After several months of dedicated deep dives evaluating dozens of new software development and no-code tools, I've settled on these resolutions: Despite Anvil still being my favorite and deeply trusted software development tool (not just in the Python ecosystem, but among every language tool I've used in 30 years), I think it'll be hard for it to compete with AI code generation going forward, especially since its integrated IDE, visual UI, visual database and project management tools are only available as SAAS products, and because its open-source runtime is time-consuming to install and heavy on system resources. Those aren't deal-breakers, especially for big projects, but there are clearly far better options emerging. For my own development work, and to extend any no-code tools that get implemented in my projects, going forward I'll choose to use Flask and its ecosystem first: Flask-SQLAlchemy for database ORM, Flask-Login for auth, Flask-Admin for quick backend CRUD grids, Jinja2 templates, SocketIO for realtime interactions + the full Python backend ecosystem, and DataTables/Bootstrap/jQuery/HTML/CSS/JS + any specialized JS libraries for all UI/front end. With LLMs generating code, that particular combination of tools has become more productive and versatile than even Anvil's entire suite of hyper-productive visual/integrated tooling. Flask is the lightest weight mainstream Python framework option, and it's as versatile, capable, mature and well established as anything out there. Most important, all the LLMs are deeply trained in how to use the Flask ecosystem effectively, and they do their best work when using the particular tools listed above. They generally produce working code, first shot, for even very complex requirements, across a broad range of typical software development tasks, when using those tools. The approach I normally follow is to plan and build first prototypes with ChatGPT, and then copy entire GPT conversations into Gemini, to get a second set of eyes on code, logic, and other implementation details in any project, and to push past the scope/context window of anything GPT can't complete. It always helps to get the perspective of multiple additional LLM models whenever a challenge is hard to work through. Grok, Qwen3 Coder and other open source models like Deepseek are already likely even better options in some cases, and all are available right now. I regularly pass tasks back and forth between models, as I would when working with a team of human developers. Each model has different strengths, and they can help each other complete challenging goals. It's also finally possible to get genuinely useful and fast enough results running local LLMs on a laptop, especially right now with a new model named LFM2. LFM2-f16 (no quantization required) produces ~7 tokens per second when generating high quality code and reasoned output, running in LM Studio, on a $150 netbook with only a low-power CPU (no GPU at all). Running the LFM2 model on even a cheap VPS server provides a much faster, usefully capable, secure, in-house LLM solution. LFM2, or any other open source model, can be used in environments which are entirely air-gapped from the Internet, for security reasons, for use when traveling with a laptop, etc. Vast.ai is my go-to for running the heaviest models which require multiple high-powered GPUs and top tier server hardware. Vast.ai tends to be much less expensive than most other hosted commercial server/GPU offerings, and there are always a massive number of hardware/platform choices available. But that's only needed in cases where HIPAA compliance is required, for example, when feeding an LLM sensitive data. ChatGPT is still cheaper to use at $20/month, and Gemini is 100% free to use in Google AI Studio. LFM2 and other small models that run on machines without GPUs are certainly nowhere near as good as the biggest frontier models, but they're getting perhaps 50-80% of the way there when it comes to writing Flask code specifically. You'll likely need to edit and debug most first-shot code generations by tiny models, but LFM2 especially provides legit enough output, fast enough, to replace massive amounts of manual coding work - and that's what's required to replace bigger framework tools such as Anvil. Options like that are just continuing to get better (I've already got another promising model (gemma-3n-e4b) running directly on my phone). For every initial database requirement, I'm now choosing SQLite to start projects, whenever it's possible and practical to use. SQLite has become robust and performant enough to handle the full life-cycle of just about any in-house project, and it can be migrated to any other big RDBMS virtually instantly, to scale up to any production environment, at the drop of a hat, without hassle. Postgres and MySQL are the best performing and most common solutions for bigger web scale projects, but MSSQL and any others can all be treated basically as drop-in replacements, as required to fit existing organizational platform choices. If/when a database migration is necessary, using SQLAlchemy typically means just changing a connection string in your Python code. Migrating to different flavors of pure SQL code can also now be accomplished quickly and easily with LLMs. SQLite performs quickly in small user environments, it doesn't require any installation, it uses trivial hardware and system resources, and it can be backed up, duplicated, and/or moved to another server, just by copying a single file. The issue of SQLlite lacking web access, has been completely solved for me with NocoDB and other no-code solutions like Teable & NocoBase (Teable even enables direct SQL select access). Those tools provide browser based UIs for building schema, queries, views, etc., as well as REST API access and webhook automations - not just for SQLite, but for every common RDBMS. NocoDB works not only as a replacement for DBeaver, HeidiSQL, for example, but also enables the pre-built functionalities in those sorts of tools, to be dropped directly into any application, and integrated programmatically (using any programming language with REST API access). NocoDB provides that drop-in no-code layer, in *addition to things like spreadsheet-like formula columns, filtered/sorted/grouped grid/card/calendar/kanban views and forms which are publicly shareable and optionally password protected, unlimited auth/user management, and built-in integrations to handle automated email sending, Twilio messaging, file saving to Google, S3, and other systems, as well as web hook connections to any 3rd party REST API, whenever a given interaction occurs, or schedule/trigger states exist in the database. That's an absolutely huge amount of universally useful capability, far beyond basic CRUD interactions, which non-technical users can control immediately. The no-code layers in NocoDB and other similar tools make it possible to work with clients in a way that dramatically improves the entire development approach, from the process of collecting requirements, through prototyping, debugging, testing workflows, and all the normal UX pressures encountered throughout a project lifecycle. Clients always know their data and desired workflows best, and giving them a safe, immediately intuitive interface to complete real database schema building, querying, reporting, and integration activities, changes absolutely everything about how developers can work with non-technical end-users. No-code tools enable clients and every other stakeholder involved in a project to complete *so much menial time consuming work (and menial does *not mean fundamentally unimportant to finishing projects). Those no-code systems don't get in the way of any preferred professional tooling such as SQLAlchemy or pure SQL. They just drop in and work directly in parallel with traditional software development ecosystems. They're safe, easy to use, and many even have trash can, undo, backup-restore, version control, and other critically useful management features which make it virtually impossbile for users to break a database system (those are so many fundamentally useful capabilities which go well beyond basic CRUD!). No-code tools can save a small-medium size project many 10's of thousands of lines of code, along with all the frustrating debugging, testing, and UX iterations, etc. which are associated with implementing and updating those lines. But most important, no-code tools provide stakeholders an immediately usable and *ongoing solution to complete their own requirements, without anything more than some periodic training, help and guidance by developers. This frees up developer time, energy, motivation, and brain power to complete more challenging and innovative project goals. From a developer's point of view, that means more simultaneously paying clients, more consistent work, more interesting work, and far less stress meeting goals on time, being tied down perpetually to supporting legacy projects, etc. BTW, the tiny Python library at https://github.com/coleifer/sqlite-web is a very effective browser-based UI for SQLite. It's an instantly installable tool which keeps you from having to work on the command line, and provides a dead simple UI for viewing & altering any schema & data in any SQLite database, with both full visual & pure SQL access (for quick project management tasks where NocoDB is much heavier than needed - it's an admin tool, not necessarily a tool meant to be integrated into end-user software - although it certainly can be integrated...). For projects that require lots of no-code client involvment, Baserow is still the slickest and easiest choice for clients to use, from the database management system all the way through to basic application building features. My clients absolutely freakin love it and every one of them has started using it immediately, with virtually no training. It's been a total game changer in how I can approach most in-house work, for a large percentage of private organization clientelle. The clients who are using it have all adopted it to complete tasks outside the initial scope of every project it's been introduced into, to solve other problems (it's just better all around in most cases than Excel, Google Sheets, etc). It is, however, a walled garden which only runs on Postgres, so it's best for projects that involve primarily lots of CRUD work, and which won't require any other core RDBMS connectivity. Budibase has the most powerful, practical, useful mix of connected no-code solutions which come in a single no-code package that is entirely free/OSS. It has a built-in database and it connects to the largest number of 3rd party database systems. All the most common RDBMSs (except SQLite), and many other NoSQL and commercial database systems like Firestore, Elastisearch, and other popular commercial offerings. It's got a very capable integrated visual application builder, and a really versatile automation workflow builder, with lots of built-in tools to handle webhooks, scheduled cron jobs, and integrations with 3rd party APIs. It's also got a huge collection of free plug-ins available, to enable special UI functionalities and features such as audio recording, video playing, payments (a Stripe drop-in, for example), integrated maps, QR/code scanning and display widgets, signature capture, many chart and visualization options, more flexible containers, multiple varied repeating elements and flex layout options, etc. You can integrate JavaScript to handle just about anything that can't be done with no-code - *but I'll typically choose to use Flask and full Python code systems for any sort of innovative work, right from the beginning. Version 3 of Budibase has slightly more mature features than v2, if you can live within the user limits of the OSS version. The 2.13.15 OSS version doesn't have any limits whatsoever on the number of users, databases, projects, etc., and it has all the same basic core functionalities, including support for up to 10 plugins per installation. With all that functionality, Budibase does have a learning curve, so it's more suited to technical users who don't necessarily have any development experience (but it's still far and away easier to learn than any full code solution). NocoBase is another strong solution for in-house no-code CRUD/workflow development, with more database connectivity, integrations, and automation options built-in than Baserow, but its admin interface is also not as appealing to non-technical users, so it won't be my first choice in most cases I foresee. I'd prefer to give users Baserow for a dead simple end-to-end no-code solution that's extendable by Python, n8n, etc., NocoDB for a more connected database-only solution, and Budibase for a solution that's harder to learn, but has the broadest collection of built-in connectivity and automation capabilitities, at the expense of a longer learning curve (which most non-technical end-users simply won't tolerate). N8N is a powerhouse for building no-code automations, with several thousand built-in integrations. It can replace Python and other full code tools for a massive variety of tasks. I'll still choose to use Python in every situation, but I'm waiting to see how many of my no-code users would prefer to take on deeper development tasks with n8n. The built-in email and webhook/REST API integrations in NocoDB have already proved to be very useful. N8N just adds a limitless number of extensions to that sort of capability, to every tool that I'll use in the future, all without code (but still a learning curve for end-users...). I've removed all the branding from my open-source installations of Baserow, NocoDB, Budibase, and other no-code systems, so users don't see, for example, 'Made with Baserow' anywhere. That makes it entirely palatable to include autogenerated, realtime no-code filtered/sorted/grouped views and forms which stakeholders can create, directly in public facing applications. You can pop no-code forms, views and admin interfaces into iframes built with any other full-code tools, to enable instant CRUD and admin functionalities, without writing any code at all. Combine those solutions directly within complex Flask, Anvil, Streamlit, SQLPage apps, for example, and migrate functionalities between any of those tools, as needed to improve prototyping speed, and to enable polished UIs with infinite capabilities, using more complex frameworks. None of those tools fight for ground when paired with any of the others - they all play beautifully together. Streamlit, SQLPage, and any other full-code tools can integrate directly with all these no-code tools, to enable users with a wide range of technical backgrounds to build extensions, integrations, prototypes for more complex systems, etc. For me and my work, Anvil has been endlessly capable, trustworthy, and a joy to use, but AI generated Flask code will likely become much more prominent in all my future projects. You can't go wrong dropping NocoDB into any project, to enable end-user involvement in the development process, and throughout the entire lifecycle. Improved stakeholder involvement in the development process, along with all the work they can actually accomplish on their own with newer no-code tools, is a game changer. But LLMs are still positioned to be the ultimate developer tools. LLMs which run directly on smaller edge devices without GPUs, as well as more capable frontier quality LLMs like Qwen3 Coder, make it possible to use previously low-productivity tools such Flask, now as the most productive choices - and you're not required to use any 3rd party hosted AI services, if you need to keep everything in-house, or even on-device. Professional developer experience is still required for most serious projects, but that is changing quickly as tools and LLM agents continue to improve. I'm glad I have music, Rockfactory, the paramotor business and other interests to involve myself in, in the future.

Baserow's realtime features are pervasive everywhere throughout the framework. That led to an especially positive experience I had with a client earlier this week. I was showing a business owner how to set up front-end forms that enable her clients to enter data into tables she creates. She creates a backend database table, and Baserow enables her to build a completely custom front-end form, with fully customizable questionnaire titles and descriptions for each field in the table (completely decoupled from any back-end requirements). Baserow displays an appropriate UI component to enable input of the data type in each field of the backend table (i.e., either dropdowns or radio buttons for single-select and multi-select fields, automatically populated with her back-end choice values, a file upload component for file fields, etc.). Baserow's instant form builder also enables users to select which fields have UI component that appear on the form, which ones are required, and it even enables logic of any complexity to show and hides fields - so for example, she had a pile of long text detail fields which were only shown when Boolean checkboxes were clicked by the user. The logic driving how fields are shown can be as complex as desired (based on the evaluation of as many other values entered into other fields - for example, if the text entered by the user into field1 contains the word 'discontinued' and/or field2 has a date value before tomorrow...) - all without any code. But that sort of functionality is getting to be par for the course with several no-code tools. What blew me away was Barerow's realtime support for the form builder interface. My client was on her phone for this meeting, unable to join a Zoom call to share screens. Every interaction we each performed on the form builder screen was instantly updated for both of us - so if I slid form fields around into different positions of the screen, made certain fields conditionally visible, etc., she saw those changes appear instantly (in realtime), without having to refresh her browser. And vice-versa - I saw all the changes she made in realtime. Anyone who's ever had to remotely teach clients how to use an application interface, knows how difficult it can be to get non-technical users to make changes to an interface, and the interactions in that training session with my client were just magically simple. It was just another super-slick example of how Baserow makes usability even more dramatically practical and enjoyable. And those sorts of realtime updates are baked in throughout everything in Baserow. During that training session, my client and I both made changes to the back-end schema of her tables, and each changed appeared instantly to each of us, so as I explained how to organize her columns, she saw the changes taking place, and I could watch and help guide her as she attempted her first changes. And of course the same is true for any data we entered in any cell - and that's the case for any data that ever gets entered into any cell in any table, for any number of connected users looking at any table in any Baserow database - always without ever having to refresh any screen anywhere. This feature alone, just sharing realtime updates on back-end user interfaces, would have saved me from *so many endless frustrating hours of interactions working with clients who have less technical skill, over the past few decades. With that feature, the entire experience of training clients to use an interface, and providing ongoing support for daily operations, just becomes *so much simpler. I don't have to open Zoom or some other approved video conference tool, share screens, etc. I can simply take a phone call, wherever I am, open the app on my phone, and show any user exactly what they need to do, instantly, without a the pain of walking a user through operations blindly, trying to explain steps to a confused employee who barely knows how to use a computer. That's the sort of practical improvement to development workflow and management, across a project's lifecycle, which are possible with these new no-code tools - and that's just one example of the sort of slick, modern usability baked into these tools (Baserow especially) - really, just the tip of the iceberg. They're so *easy and intuitive for non-technical users to operate. My clients using Baserow are experiencing skyrocketing productivity, getting rid of entire paid 3rd party systems that they'd previously relied on to handle specialized workflows, and doing it all dramatically easily, only needing hand-holding when trying to understanding how to structure and best normalize their schema, and when conceiving how to use Baserow tooling to complete more and more data management and communication tasks - they're discovering how its possible to integrate anything they do in Baserow with other 3rd party systems, and what use to be a long-term development commitment for me just ends up being a simple in-house task for my clients' employees. And whenever they need some specialized functionality to enable a features, I just build that functionality in Flask, and pop it into an iframe in their Baserow no-code app builder, or simply return data to a call they make in the no-code builder, etc. I don't have to wade through tens of thousands of lines of SQL queries, potentially break existing project code pushing changes, etc. - concerns are all beautifully separated - we just create an API key to work only with the tables that need to be dealt with for any feature, and enable read-write only for those fields, as needed - and then connect to the Baserow REST API, with the API key needed for that functionality. So onboarding a new software developer is virtually instant - they don't need to see or be involved with anything else in the entire project - just learn how to use that particular REST API. It's so ridiculously simple and safe compared to traditional development methodologies. This sort of workflow is what I've been imagining would be possible, for more than 30 years. It utterly decimates any sort of traditional software development workflow that was possible previously. And all these sorts of features rely on zero AI involvement, just solid core framework engineering - although Baserow can integrate any MCP server you create (even in the open source version), and has built-in AI help for building formulas, and for creating AI fields that connect to a variety of LLMs (those last 2 options are paid features which none of my clients have needed yet, but they're immediately available as drop-in solutions, whenever they might be useful). It's hard to explain the joy these sort of innovations bring me. My interactions with clients using Baserow and several other modern no-code tools (NocoDB has been the next most used tool recently), have been absolutely enjoyable, and my perspective about future interactions with them is just so pleasant to anticipate. Supporting Baserow development efforts just feels outrageously easy, it's completely different than anything in the past. And with generative AI, building extensions with Flask, for example, just goes so unimaginably quickly. For example, I built a secure realtime messaging system for a client this past weekend - the same weekend I also ran a huge Rockfactory recital performance event (I was as busy as a person can get) - to replace a system she's currently paying $500/month to operate. That messaging system forms the core of all her operations with clients, patients, providers, employees, etc. Everything her business does internally and publicly runs through the realtime messaging system. I included encrypted message and file transfer - all data is fully encrypted at rest by the software - kind of overkill because it runs entirely on a managed server with a dedicated IT team monitoring all network activity - and every user has to access to the app on a private secure VPN - but none of that was a challenge, and none of that used Baserow (all Flask and Socket.io for realtime features). That sort of application would have taken at least a few weeks to build in the past. With AI and my current choices for development tooling, it took just hours, and was painless to complete. And now my client has a fully self-hosted system that she can adjust and add features too as needed (they hated the UI of the paid app they were using). She's focused on selling her business eventually, so this will be a huge added value for potential buyers. These are the sorts of things that I absolutely dig working on with clients. Let that sink in - it just took a few hours of work to build that entire system. And most of the work that employees, owners, and stakeholders accomplish with Baserow, doesn't require any help from me. I can work with more clients, worry so much less about supporting legacy projects, focus on building interesting features, etc. This is the future I had always hoped for and imagined :)

The benefits run so deep for the particular choices of tools I'm currently using. For example, one of my clients who's started using Baserow, has an employee with some previous Python experience. That employee had created a simple CRM software for a real estate business, for a previous employer. He's not a developer by trade, just taught himself enough to use existing tools to build a useful in-house system with Flask. So now he can build prototypes to extend Baserow functionality. This saves me a huge amount of time and effort communicating with my client, even if her employee doesn't end up writing any lines of code that actually get used in production. Working with the Baserow database API is as simple as using any other API for any other 3rd party service - anyone with any experience doing anything with any REST API, in any language, and learn to use it immediately. And remember, you make as many API keys available to limit interactions with only particular schema in Baserow tables, so you can isolate and separate concerns with perfectly fine control. So my client and her employee with Flask experience can work among themselves, brainstorming how to extend their Baserow functionalities - entirely focused on their own perspective about how details of their own daily workflows can be best handled. Her employee can propose solutions, and actually build prototypes, to the best of his ability. And remember, Baserow has a huge set of features such as a trash can to restore any accidentally removed values, from individual cells of information, all the way up to entire tables and databases. And Baserow has dead simple incremental backup functionalities to save and restore entire databases and applications, at any number of restore points - and you can even save entire workspaces, with all the complete database & application structures in an entire set of projects, with or without all the data too, all with a single button click (and you can migrate those entire workspaces to any other server, with a single button click - jeessuss that's incredibly productive and powerful). And developers can preview and test versions of apps built with the Baserow application builder, before publishing any changes to production - and Baserow even creates network subdomains as needed (Caddy is built in and automated), and you can create as many duplicates of apps, as needed for testing, etc., etc., etc. The point is, my client's in-house development guy can build as much as he wants, without breaking *anything in the system. My client and he can powwow as much as they want about how they envision their internal system being built, and he can do as much as possible, within his skill limits. I just come in at the end of any in-house effort they work on, fix up his prototypes, suggest changes and improvements, and publish them when they're fully ready for production. Along the way, we all use generative AI to boost productivity tremendously. Can you imagine how difficult it would be to enable that sort of interaction safely and conveniently, in any other sort of development environment? BTW, because the Baserow database is accessible entirely via REST API, I can have my client's in-house Flask guy build his applications on a totally separate development server than the production server, so he never has to touch any production server infrastructure, or do any work on the machine that handles production application features or the production database. And he never touches any other part of the database than precisely what his Baserow API keys enable him to read and/or write to, for any piece of any development effort. It doesn't get more ideally controllable/manageable than that. This enables end-users, owners, managers, and stakeholders, with any level of technical ability, to safely take part in an absolutely huge portion of the development process of any business system. Public and in-house users get an absolute slick product in the end - because the Baserow system is so slickly designed, from the ground up. Employees without any tech background get to help build schema, queries, forms, views with filters/sorts/groups and complex UI layouts (responsive grid and gallery/card layouts, calendars, kanbans), realtime interactions, etc., all immediately, starting with just a few minutes of dead-simple training, and progressing through every level of complexity. Prototype schema can be separated and simply copied into production tables when they're ready for use. More technically capable users/stakeholders can be trained to start using the Baserow app builder, in a few days. Stakeholders with any software development experience of any sort, in any language or using any tooling of any sort (think N8N, Budibase, Appsmith, etc.), can take part in building and integrating more specialized and complex/innovative features. And it can all be done safely, rolled out to production easily, with utterly simple roll-back capabilities that keep any part of the system from ever getting broken more than momentarily, and without ever having to worry about data loss. These tools enable every human resource in an organization to contribute maximally to how a business' computing systems work. That affects absolutely everything about how an organization and all its people can be most successful and happy in their work. This is truly awesome tooling, and together with AI, the ability to build technical systems is becoming dramatically simple.

BTW, I just saw that teable can present a spreadsheet view of any table, right along with all the other typical views (grid, gallery, calendar, kanban, form). The spreadsheet view, with is a free plugin, includes all the typical formulas and workflow interactions that are available in most spreadsheet applications - but with all the data saved directly as Postgres or SQLite tables (however you install it on the back end), and those tables are integrated directly with all the other features of the Teable system. Teable also has built-in charts, it lets you build and present SQL select views, and has trash can, undo-redo, and all the same real-time features that the Baserow UI and admin interfaces present (so I could show users how to build forms, in real time, just like I did with my client earlier this week in Baserow). It's a lighter weight install than Baserow, but doesn't have any application builder, it doesn't have complete project export/import features, or even web hooks yet, but it's another drop-in alternative, perhaps useful for any lighter one-off projects where built-in spreadsheet functionality is a critical requirement for users. I'm having so much fun exploring these tools :)

So now I wonder how well NocoDB and Budibase will integrate directly with the back end database structure of Teable (NocoDB and Budibase integrate instantly, but they don't do real-time, have spreadsheet plugins, etc). That would combine all the Teable features mentioned above, together with all the webhook, integration, automation and super powerful application building features built into NocoDB and Budibase - and of course, add in N8N and/or any programming languages needed to build any conceivable extended, innovative functionality. So much fun :)

My Docker skills have gotten a lot better over the past 3 months, from installing so many dozens of tools that have quick docker and docker-compose installations available. I think it would be great to create a single installation with all of my favorite recent tools pre-integrated in a single one-line installation, with: Postgres, MySQL, SQLite, Python, anvil-app-server, Flask and all the most used Flask libraries already installed, Bootstrap, jQuery, and all my most used JS libraries included on the server, plus Baserow, NocoDB, Budibase, Teable, NocoBase, SQLpage, Streamlit, sqlite-web, etc. - every tool that I've found to be useful to any group of stakeholders, analysts, developers, etc. - with synchronized databases pre-configured and ready to go, some pre-configured example apps and templates which demonstrate how easily any of the tools can be integrated together... That's a little side project which would be super useful in the future - just spin up a VPS with any hosting company or any IT department, run a command line script to download and run a docker-compose.yml, and come back in a few minutes to a server with every one of those tools ready to use - haha, that's gotta get done :)

Add to that Ollama, OpenWebUI, and a bunch of pre-installed small LLMs (LFM2, Gemma 3n, etc.), so that the entire thing, including AI code generation, is usable air-gapped from the Internet if needed, and/or still runnable on a $50/year VPS :)

Oops, I also forgot to include N8N in that list.

Toss in A-Frame, Coppercube and GDevelop for some web based VR, 3D, and general game development capabilities (Coppercube and GDevelop are no-code, A-Frame is a very low code VR framework).

For my work, Python, Flask, Postgres and NocoDB, and a few mini LLMs will do it all (plus, include all the most used Flask libraries + SQLAlchemy, Bootstrap, jQuery, and all the most used JS libraries on the server (like Datatables - I love that library), so it can be run air-gapped from the Internet if needed). And of course SQLITE is included in Python, and Postres/NocoDB aren't required. So that means my most-used stack is just Python + Flask/SQLAlchemy libraries, and an LLM. And Python comes default in every common version of Ubuntu an other default OSs on most VPSs, so there's nothing to install (maybe pip and nano, depending on your OS distribution and the version of your Python distribution, plus Flask and SQLAlchemy). So clearly there's no Docker needed for any of my own development work. Flask even runs in Python on mobile phones, and on ancient machines. If you need to run on very old machines, just use Bootstrap 3.4.1 and SQLAlchemy 1.3.24. That works on servers with ancient Python2, and the UI works in virtually every ancient browser - and still looks and works great for almost any need in modern browsers. Bootstrap only, BTW, does a great job of building datatables (grids), with sortable columns, pagination, search, etc. Datatables is a great drop-in that works with virtually any other combination of web UI tools - so I don't worry at all about any other combinations of tools in the tool chain to get beautiful CRUD grids - just a rest API on the back end (which of course is handled by Flask or any of its alternatives: FastAPI, Microdot, etc).

Here's a little summary of my most recent ramblings regarding software development tooling: For my work, Flask and its ecosystem, together with AI code generation, is quickly replacing all other tools (including Anvil). The forum app demo below consists of a single file, just over 450 lines, including all HTML/CSS/JSS templates, all database code, all auth (with signup and email validation routines), inline datagrid editing (multi-sort, search, pagination), as well as separate form editing, completely separate CRUD admin grid, etc. https://flasktutorial.xqx1.com All the features in that demo are made with ~450 lines of code, total. It uses Flask-Admin, Flask-Login, Flask-SQLAlchemy, Flask-Email, Datatables.net, Bootstrap, etc. Animate.css is not included in this demo, but it's a common part of the stack. Here's the code: https://com-pute.com/nick/simple_forum_flask_sqla_admin_login_styled_register_crud_datatables_inline.py Create a new account, or login with these credentials, to see all the admin features: email: admin@example.com password: admin The realtime chat app below uses socket.io for pubsub (instant automatic updates without refresh). It's also got file transfer, message encryption, group and sub-group subscription/approval, and full admin panel features. Like all these Flask demo apps, it's tiny, requires trivial hardware and OS resources, and takes less than a minute to deploy in production (all these demos use SQLite built into Python, but can use any RDBMS which SQLAlchemy connects to): https://messaging.cmpt1.com Use the same default email/password to try the admin features in the app above. Those are just trivial demos, to demonstrate how easily all the common features of modern web apps can be implemented (auth, db CRUD, datagrids, realtime updates, encryption at rest, etc.). I've recently been building much more complex production applications with this stack. Gemini, GPT, and all the other frontier models work perfectly well generating significant code bases using these tools, with very few first-shot errors. I've been able to finish fully customized production applications involving several thousand lines of code, exactly to client specifications, in a day, using Gemini and this stack. Local models including LFM2, Gemma3n, and Smallthinker are all getting good enough to quickly generate useful code for this stack, directly on laptops, phones, and VPSs without any GPU. Anything in the Python, JS (any web UI framework), and RDBMS ecosystems can be integrated in this stack - which means basically anything in common use can be integrated. It's getting hard to see any reason to use anything else at this point. Even dramatically productive integrated suites of tools such as Anvil can't compete with the productivity enabled by LLM code generation. If Flask isn't suitable for any reason, FastAPI, Tornado, Bottle, Microdot, and any of dozens of alternatives can be used as drop-in replacements when more performance, usability in Micropython, for example, or other specific requirements come into play. Then, drop in NocoDB, Teable, Budibase, N8N, https://github.com/coleifer/sqlite-web, and/or any alternatives to work directly along side SQLAlchemy (or pure SQL), and you've instantly got all the most important no-code capabilities added to a project, in parallel with the stack above. For projects where the majority of the work is CRUD data management, no-code database tools dramatically ease absolutely everything about the entire development process, as well as all the pain points involved in providing long-term/legacy support across a project's full life cycle. End-users can focus on learning an endlessly extensible system, rather than just an application with limited functionality, which requires constant updating to add new schema and basic CRUD interactions. Combining open-ended no-code database functionality with specifically developed novel/innovative application functionality, is a powerful approach to building long-terms solutions with changing requirements. NocoDB is the lightest weight no-code option, of the choices above, with support for MSSQL/MySQL/Postgres/SQLite and built-in email/Twilio/Google/S3 integrations (Note: use version 0.250.2 for MSSQL support). Teable has a full actual spreadsheet interface plugin (super useful for some projects!). It supports Postgres/SQLite, and does automatic realtime UI updates out of the box (even when multiple users build schema, forms, and edit data simultaneously - Baserow is the only other no-code system with comparable realtime features). It also provides additional useful features such as trashcan and undo/restore capabilities, and a SQL select query (code) interface, available directly in the UI. Budibase has the most capable application builder, with support for the largest number of databases and endless plugins (audio, video, payments, maps, QR codes, signature capture, charts, 3rd party integrations, etc.), as well as a powerful automation workflow builder - but it also has the biggest learning curve of similar tools, and it's comparably resource intensive (Note: use version 2.13.15 for unlimited free/OSS features). N8N provides the greatest number of no-code integrations with 3rd party tools/services, and the most complex automation workflow builder. It can replace Python and other programming languages, for a wide range of integration tasks, without requiring any software development experience. https://github.com/coleifer/sqlite-web is the lightest possible browser based SQLite manager (a dead simple DBeaver or HeidiSQL alternative for SQLite, that only requires a quick pip install). It's meant to be solely an admin tool, but could certainly be integrated in software. Toss in A-Frame, Coppercube, GDevelop, and Godot for any sort of no-code/low-code web based VR, 3D, interactive graphics/media, or general game development capabilities. The sorts of requirements those tools satisfy are typically not a part of normal business application development routines, but they're perhaps useful for advertising and some client engagement purposes, demos, etc. I've built applications for psychological research, for example, using them and other similar tools in the past. All of the no-code tools above are usable by end-users/stakeholders without any software development experience, though they still involve a learning curve. Streamlit and SQLPage are useful frameworks for data scientists, analysts, and other stakeholders in organizations, who already have some skill with Python or SQL. Jam.py can be extraordinarily productive for developers who already have experience with Python, HTML, CSS, JS, Bootstrap, and jQuery specifically. It speeds up CRUD datagrid and UI form development tremendously, and is a very lightweight option compared to any other no-code tool, even NocoDB - and it's totally white-labeled (although I have successfully edited versions of all the open-source no-code tools above, which have all the branding completely removed, so that is not an issue). All these additional tools integrate perfectly with all the other tools listed here. Baserow is a totally separate no-code solution which is ideal for clients who want absolutely the simplest possible user experience, with the slickest possible interface, from database to app building, with virtually no learning curve involved - especially when HIPAA compliance is required and real-time UI updates are needed, all in one stand-alone package. Baserow also provides the simplest project management, version management, snapshot/back-up/restore/undo/trashcan and other features that keep users from making permanent mistakes deleting data - and which also enable easy/instant migration between servers. Baserow only supports Postgres though, and requires payment for some of the bells & whistles that are free in the other no-code tools. It's hard to express just how easy it is to get users working with Baserow - in many cases, applications just never need to be built for CRUD purposes - and Baserow comes with 100+ useful starter templates for common business purposes. LLMs are able to build code that integrates instantly with Baserow APIs and web hooks (and that's true of other similar no-code database tools such as NocoDB). Combinations of NocoDB + Teable + Budibase + N8N together certainly can provide far more no-code capabilities than Baserow alone, and with features that are entirely free/OSS (totally open source, no fees whatsoever for any features, for life), but Baserow's immediately intuitive usability is hard to beat, for clients who will thrive on having many non-technical employees, managers, owners, stakeholders, etc. implement database and application building capabilities, with the least amount of training possible. The Flask stack above can be used to build extended functionalities for any of the no-code tools. For developers, it's all that's needed to build just about any sort of end-user application. I'll most likely drop in NocoDB as a no-code interface to specialized applications which are built fundamentally upon the Flask stack from the ground up - or I'll add Flask extensions to Baserow CRUD applications/environments which are built primarily by end-users.

The most common extensions for Flask are: Flask-login Flask-SQLAlchemy Flask-WTF Flask-Mail Flask-RESTX Flask-debugtoolbar Flask-limiter Flask-socketio Celery Flask-HTTPAuth Flask-admin Flask-caching Flask-security-too Flask-session Gunicorn Pytest Alembic Flake8 Flask app builder Flask-bootstrap Flask-googlemaps Flask-migrate Flask-paginate Flask-sijax Get links to them and many more, plus tutorials and other resources, at: https://github.com/humiaozuzu/awesome-flask

I asked GPT to create a tutorial covering the most common Flask extensions, and also to make a detailed tutorial explanation of the basic forum application above. I edited its responses into this 50 page starter explanation: https://com-pute.com/nick/flask_tutorial_gpt_inline_forum_explanation.txt https://com-pute.com/nick/flask_tutorial_gpt_inline_forum_explanation.pdf

GPT-OSS-20b is absolutely killer at generating Flask code (+ most other code, and most other topics), and it runs on machines without a GPU. Considering they're giving that away for free, I expect GPT5 is going to be mind blowing.

GPT5 doesn't *feel mind blowing at this point - more like a step closer to the frog boiling ;)

I wrote this to a client trying to decide tools to learn and use for simple projects: Learn flask+HTML/CSS/JS/etc and use LLMs to help make writing code far more productive. Add NocoDB if you want users to have an interface to build schema, queries and views. Jam.py combines both those features, and also uses HTML/CSS/JS/Bootstrap/jQuery to build UIs (everything but the autogenerated CRUD forms and grids), and everything on the back end is done in Python, plus it includes simple IDE features which make the development workflow more productive - but you won't get much help from LLMs writing jam.py framework code (which could derail your work until you really understand HTML/CSS/JS/Bootstrap/jQuery and the full jam.py framework). Streamlit eliminates the need to write HTML/CSS/JS/AJAX/etc., it lets you write all code in Python (use SQLAlchemy or a SQL driver to wite database code), and LLMs can generate Streamlit code well. Streamlit generally requires a trivial amount of code to accomplish most goals, but you're stuck using its UI system, which can be very powerful, but state management is tougher to understand, and you can't integrate other tools in the vast webUI world. Flask lets you use *any webUI tools, but then you have to deal with all the complexities of those webUI frameworks (which is mitigated by relying on LLMs to do much of the work). Anvil integrates a massive set of tools, in an end-to-end environment that helps every piece of the puzzle work together as effectively as humanly possible, but AI code generation even beats the productivity of that fantastic system. So the choice of flask is to avoid limitations and to enable LLM code generation in the most effective way possible. The choice to add NocoDB to the mix (or any comparable no-code tool), is to enable end-users and stakeholders to take part in database development in a way that solves end-user issues, and involves them in a way which pushes development forward, and handles maintenance so much more painlessly. It works entirely in parallel with any other software development tools (and ends up accomplishing so much of the development work, effortlessly (and with fewer potential errors)). I just think at this point, you can rely on LLMs to do a better, faster, more effective and efficient job than most people writing code, so you may as well begin to use them as core development tooling - and use a framework that enables that best. In the end, Python and database code can be ported between any of these frameworks as needed, so any of them is viable, and for your current work, you can choose any without worrying you're making a breaking decision. Streamlit and Jam.py can end up using less framework code, so they can more easily be fully learned, to handle lots of work, without relying on LLMs to make the development process less time consuming, but there are limitations either in capability or the ability for LLMs to work with them as effectively in the long run. In the short term, and going forward, LLMs enable the easiest possible solutions, even if the framework is more complicated - because they can work with Flask and a few other frameworks best (along with everything that can be integrated with those particular frameworks). The no-code tools enable everyone to work with the database, without having to write any code at all - and that improves everything about the entire development process and software lifecycle, without necessarily getting in the way at all. In the end, use the tools that get projects completed for your needs - go with what gives you results. You'll likely get the best results at this point using GPT and Gemini to write Flask code, and learning to use all that ecosystem along the way (and of course everything you learn doing that is directly applicable in jam.py, Anvil, along with NocoDB, etc.). I can help check generated code for production, or help when you have questions, but the frontier LLMs are also great at evaluating/refining each other's work, through iterative revisions, until they all agree on a final version - treat that just like working with a team of human developers (who can write 1000 lines per minute). And they can help with every step of installation, implementation, and with every decision you make along the way about which tools to use, how to deal with anything you don't know how to handle, etc.

See my notes about testing GPT-OSS 20b, compared to other models that run on CPU only, in the AI thread. It's the one to use locally.

Lately in practice I've been using Baserow and NocoDB for the no-code pieces of projects. Baserow has been working fantasticly for the clients who've been using it. We've gotten some significantly sized production databases created with it (some with schema that has been expanded daily over the past 10 months), and it's being used in production apps which connect to many of those database tables via the Baserow API. I have *not used the Baserow app builder nearly as much as I had initially expected. It's now so easy to build the typical sorts of CRUD interfaces that would be created with the app builder, using GPT instead, that I'm not sure there's really any need for any CRUD application builder of any sort, in any environment really. The sorts of apps that can be built with the Baserow application builder in a day or 2, can typically be built with GPT in an hour or 2, and the features of apps built in Flask with GPT, for example, have none of the limitations inherent in no-code app building tools. I just don't see end-users and stakeholders being too interested in building applications, in the same way they are in building their databases. It seems that the killer features of Baserow are really the schema and view creation features, along with the ability for users to create and share forms, filters, sorts, groupings, etc. as well as the 'IT' related features such as workspace creation/management, server migrations, backups and trash/undelete, webhooks, and of course API connectivity. NocoDB includes all those features except for trash and some project management, migration, and backup capabilities - but depending upon the RDBMS, most of those 'IT' management capabilities can be handled very easily (especially for databases stored as single SQLite files, which I use whenever practical - recently I've used SQLite for bigger and bigger endeavors, without too much worry because SQLite is just so easy to migrate to bigger RDBMSs if needed). NocoDB has some better webhook functionalities and 3rd party integrations built right in (email, Twilio, S3, etc.), more fine grained auth/user management and more types of views (calendars, kanbans, etc.) for free, and it's much lighter weight and quick to install (takes 1 minute). The really big benefit with NocoDB is that you can connect it directly to any existing common RDBMS instance (Postgres, MySQL, SQLite, MSSQL), which is what I do immediately with almost any project that colleagues create. Not only does it provide a fully functional instant admin panel, but also all the sharable views, forms, etc. which constitute how in-house end-users want to interact with their databases, for all CRUD functionalities, auth, etc. NocoDB just isn't real-time, as are Baserow and Teable. Teable does already support Postgres and SQLite, which is really enough for many of my clients, and it has that killer spreadsheet plugin, but it doesn't do webhooks well yet. I'll be watching Teable - when webhook support matures, it will likely become a real competitor for Baserow for situations where real-time updates are critical. For the near future, I expect NocoDB will become more and more important as a foundational piece of my stack. The routine more and more is that I build apps in Python/SQLAlchemy, and just hook up NocoDB in parallel for end-user and admin access to any created databases. And then of course end-users can create any databases they need for their own purposes - and I can connect apps to the databases they create either via the NocoDB REST API, or with SQLAlchemy. That's all so simple, and handles so much of the CRUD, grid/card/calendar/other views with multi-filter/sort/group, auth, admin, webhook, common 3rd party integrations, etc., which used to take up the overwhelming majority of time building business apps. I can work entirely in parallel with GPT to build innovative application features for any database, without disrupting the no-code workflows. This has been the most ideal development environment tooling I've experienced yet. The no-code tooling eliminates so much of the traditional software development workflow, so much of the time needed to write requirements, build prototypes, write/debug/test database schema and query, etc., and it offloads so much of the work that stakeholders want to be in control of in the first place - to the business owners, managers, employees, etc. who know their data and workflows best. I just regularly help them build sensible schema, normalize data structures and relationships between tables, engineer workflows which enable useful webhooks, built-in integrations, etc. The choice to use the database REST API and/or SQLAlchemy makes is super simple to integrate remote systems, and/or to optimize local performance. What an awesome world to be a part of :)

When I take a step back from the software development work I'm focused on completing, I have to really acknowledge just how much no-code tools have changed the nature of my software development work this past year. Of course it's always at the forefront of my attention how LLMs have tremendously improved my bandwidth and ability to get development work completed quickly. They don't just improve my ability to learn quickly, to get up to speed with understanding the context of requirements, within complex organizational workflows, compliance obligations, etc., to communicate better with all parties involved in a project, to dive right into building solutions without worry that I'll hit painful dead ends - and of course they reduce my stress and fatigue while building code bases, they help me make technical choices about which libraries and tools to use, help me understand the purpose and functionality of data structures involved, etc. - LLMs have been the star of the show lately in my head. But when I really look at what's happened at organizations using Baserow and NocoDB, I'm struck hard by what's actually been *accomplished with those tools. With very little hand-holding, I've watched stakeholders build some pretty staggeringly deep and useful databases - with the all the UI forms and views needed to make them actually help users get work completed. From beginning to end, no-code schema, views, and forms have been used to complete a shockingly large number of workflows which would have required a lot of drudging CRUD development work in the past. Only once this year have I had to help completely engineer a no-code schema from the ground up, along with UI forms, views, webhooks, etc., to manage a very complex multi-part workflow which involved several different stages of user group involvement, along with deep integration in an application which I built separately. Otherwise, I tend to help users understand only how to normalize typical many-to-1 and many-to-many relationships, and help them understand how to create basic views and UI form workflows. That's been simple and fun work which everyone involved tends to find satisfying - not too technically challenging or frustrating - more like enabling and useful. After basic introductory instruction and some ongoing simple help, what users have completed on their own with these tools, is absolutely staggering. If they had needed to rely on me to build schema and queries for these databases using full code tools (SQL, SQLAlchemy, and/or any ORM(s)), I could have employed 10 developers full time throughout the year. Since I'm focused on building applications which connect to these databases, my attention has been on the effectiveness of LLM code generation, but when I really consider how far my client organizations have been able to improve their data management situations, the no-code tools have been rock stars. For me, the really interesting projects always involve novel application features which I'm asked to build - but the CRUD capabilities which form the basis of that work still form the critical necessary foundation of every project - and the no-code tools have turned that massive amount of work into a mostly trivial side concern for me (just helping workers when they need guidance and support). The owners, managers, and employees have gotten a *massive amount of CRUD work done for me - and they're *happier to be enabled to do that. They know their workflows and their data, and their vision about how they want to manage their data effectively. They consult with me regularly about how to best organize and link tables of data, and how to build filtered views, UI input forms, etc., as well as how to build schema that I can connect with in applications I'm commissioned to build - but then *they do that CRUD work, all on their own. That has only very rarely been possible using any sort of code tools in the past. Using a few select no-code tools, it's now easy for them to accomplish, and they have the control they want - and neither I nor they have to go through endless agile revisions of requirements preparation, prototypes, communication about how the data structures need to be adjusted, etc. They're enabled to work with real schema and data in malleable ways, entirely on their own - and that's a game changer which has far reaching repercussions throughout the life cycle of every project. Baserow and NocoDB are powerful, versatile, safe and effective solutions, which keep end-users from having to wait for me to build CRUD software - and everything they build with those no-code tools, forms structured data which I can use in full code application development (and of course, I can use LLMs to help reduce the complexity of that process). When I look at what's been accomplished with no-code tools in my projects this year, and compare it to solutions and workflows I used to complete big projects which began just 2-3 years ago, it's strikingly clear just how much more productive, effective, practical and painless the no-code tools are, throughout every phase of development and the lifecycle of software projects. It's fantastic that users of software can help build their own software as needed and imagined. That capability adds an extraordinarily powerful and elegant solution to the common problems and pitfalls of traditional development approaches. The practical work that gets accomplished with no-code tools can't really be replaced by LLMs yet, because what no-code tools do is enable a large group of stakeholders to build out the database of a project - in the ways they need and want. What I've been discovering is that in practice, that's work which is really best left to them, instead of a development team. It's easy for them to accomplish with the right tools, and not only does it form a real foundation for actual software development, it simply eliminates the need for most CRUD software development work. The CRUD foundations they complete can be wired up easily in real software development tools. I couldn't ask any non-technical stakeholders to try and build reliable CRUD software with LLMs - that would be an utter mess, and I could never trust anything which anyone built that way. It would likely take longer to review and test 'vibe-coded' CRUD solutions than it would be to just build it myself. But those issues are entirely solved with Baserow and NocoDB. Those tools enable enormous swaths of CRUD work to get completed easily, quickly, reliably, in a consistently structured environment, by a team of non-developers. Looking back, I'm amazed at how effective Baserow and NocoDB have been - how much work they've eliminated, how much has been built with relatively effortless ease, and with a lot of practical satisfaction among clients (owners, managers, end-users, their contractors and clients, etc.). It feels pretty darn magical to have gotten so much work done in such a slick and useful way - and everyone is better for it. The users who build with no-code have gained a new capability and understanding, and we can work together so much more easily when they have that understanding. They've stopped relying so much on disparate Google docs, spreadsheets, emails, and all sorts of other scattered personal tools - we just put everything in their managed, secure Baserow and NocoDB environments, where it can all be immediately integrated directly with real software development tools. And I don't spend any of my time or energy writing/debugging/testing/updating schema or query code any more - doing that would feel so barbaric at this point - even though it constituted a large majority of my time in all the decades leading up to this moment. And of course that work forms the overwhelming effort and time needed to complete any typical business software project - it's basically eliminated at this point, replaced by much more natural and intuitive tooling which even non-technical users begin to master immediately. It's so important to understand that not all no-code tools are created equal. The way that Baserow and NocoDB (as well as Teable, which I haven't used yet in any big production projects) enable users to create and move schema around, to enter, copy, paste, and drag entire selected grids of data, for example, so easily - that's what makes all the difference in the world. For non-technical users, the slick interface is what enables its use. Tools with old 'admin' types of UIs simply would not get used. They'd be hated. I've gotten to love Baserow, but I think I could do all this with just NocoDB (and Teable may end up being an alternative, but certainly not required). That's a tiny tool in the scheme of things. Just as importantly, all the LLM development help I enjoy using could be accomplished entirely with GPT-OSS:20b running on a local PC, along with Python and a local repository of the most common libraries (especially the Flask ecosystem), and SQLite, Postgres (plus MySQL, MSSQL if required in client environments). I'll of course continue to use GPT and Gemini, pip, pipy, and all the Internet based, remotely hosted tools, but it's reassuring to know I could do all this work entirely with tooling that can fit on a flash drive, and which can be installed and run in a few minutes, entirely on an inexpensive self-hosted laptop (and/or accessed by remote desktop share on my phone, etc.). Anvil and some other tools like jam.py were great stepping stones which led to this current environment. If LLMs didn't exist the way they do, I'd likely still be using them. Anvil and jam.py include no-code DB tools, visual tools to build UIs which I now use LLM code generation to speed up, project management tools, code completion, etc. which can be handled more effectively with LLM code generation and a simpler pipeline. The point is to clarify just how staggeringly productive and earth shakingly better software development has gotten, with just a few simple to use tools. Give me NocoDB, local GPT20b, and a local repository of libraries, and everything about software development is entirely different - worlds of productivity and joy away from where it was just a few years ago. Give me a project that would have taken hundreds of hours and lots of pain to complete a few years ago, and it's now a part-time week of effort and lots of joy to complete - for everyone involved. That's staggering progress.

I'm exploring Lodefy a bit as a side interest. It ticks a lot of boxes needed for simple, high productivity full stack application development. https://lowdefy.com It shares the super-simple hyper-productive feel of no-code builders, but there are no visual drag-drop pieces. It all just consists of very easy-to-use yaml configuration, to build GUI, logic, auth, DB interactions, etc. For me, an important part is how well LLMs can generate Lodefy 'code' (config files). That would enable some of the best of every world - the productivity of LLM generated code, but using a system that's just as fast and practical to hand-code, easily read, instantly understand and adjust, and which can be used by less technically experienced stakeholders, etc. I love the idea of a fully code/text based full stack system which is as easy to use as visual no-code tools (I've been searching that for a few decades...)

... and of course, NocoDB can connect with any database a Lodefy application uses.

Looking at Lodefy in practice, I'm not convinced it actually does enough to simplify everything in the development process, to justify using it over Flask. It's very capable, but in my initial tests, not as versatile and able to be used as well as Flask by LLMs. The benefits of the no-code visual database management systems in Baserow and NocoDB are absolutely outstanding, but I still haven't found anything better than using Flask and its ecosystem, along with GPT, to build web applications. For my needs, the best answer yet to enable stakeholders to involve themselves in building applications without coding is still to use LLMs and Flask - just providing starter prompts with enough context is enough to get them going creating prototypes. But as I mentioned previously, I don't see stakeholder really being interested in building custom apps. What they're interested in, and where they really help throughout the lifecycle of a project, is in building the database. This has been one of the biggest improvements in all my experience as a developer. Stakeholders get control of their data, and I build apps upon that database.

I made a leap of faith with one particular large project during the past few months, really relying on no-code, together with using GPT to write most of the custom application code. After 2 1/2 years of learning what does and doesn't work with LLM code generation (tooling, frameworks, prompts, context management, codebase management, the workflow I described above, etc.), the project has so far been outrageously successful. A significant production database has evolved with Baserow, over the past half year, with hundreds of tables, many non-trivial relationships, UI input forms and sortable/filterable/sharable views, authentication, etc., in a workspace that's been super easy to manage, back up, duplicate and migrate between servers - all with no-code, which has been immediately usable by all the stakeholders (owner, managers, employees, end-users). We have the whole project hosted with Atlantic.net's HIPAA VPS offering, and the entire system has been built to be rock-solid compliant every inch of the way. I regularly spend time training users how to use the Baserow interface and to normalize schema, but that mostly consists of simple work, such as showing users how to import CSV files, manipulate columns, set up data types, copy/paste values, avoid wide tables with duplicated values, link many-to-one relationships, use lookups, write formulas, aggregations, etc. - just generally how to use the dead-simple UI system. Having stakeholders involved in doing this labor has saved me many hundreds of hours of grunt work building schema and performing data entry, but more important, it's changed how the entire engineering approach works, from the ground up and throughout the lifecycle of the project, because those stakeholders know their data and intimately understand its meaning, as well as what they want to do with the data. Is this environment I've no longer had to rely on endless meetings or constant cycles demonstrating prototypes to discover schema requirements. I give users a few rules about *never deleting schema, and only ever making changes to *duplicated columns, whenever any sort of schema alteration needs to be migrated. And Baserow has a full suite of tools to keep data/schema from ever being permanently lost (undo, trash can, backup/restore and audit features, etc.). So far, everyone has just immediately understood how to use Baserow - it's been a rock star which has been utterly painless to work with. I've had zero complaints from any users. They all love it. In this project, stakeholder involvement in the development process has ended with the database and CRUD interactions. They build schema and malleable views, and enter data. That's what they want to be able to do, and that's what I want them to be able to do. Basically all integrated custom software development for this project has been completed by connecting auto-generated Baserow API endpoints to requests from Python functions in Flask, and the UI has been completed with typical Jinja HTML templates, Bootstrap, jQuery, Datatables.net, any other required JS libraries, etc. - even for all the real-time features (any other web UI can be implemented in Flask - those are just the ones I've found LLMs can use 100% reliably, without hiccups). I collect requirements from the stakeholders, write detailed SRSs for GPT (and GPT typically helps with reasoning, planning, and chosen directions to satisfy those requirements, researching library and infrastructure choices, for example). And in this project, I've let GPT take the wheel for all custom application code generation. I've spent a huge amount of time writing prompts, debugging, and testing code, but the coding work has been nearly entirely completed by GPT - and the results have been breathtaking, both in terms of speed and quality of output. A complicated real-time messaging system has been built, with a massive set of hard-to-implement features, a pile of deep workflows for patient intake and care management, with an entirely in-house geolocation/mapping system, all sorts of multimedia bells and whistles, notification systems, scheduled background processes, specialized user role features, etc. Once the project got rolling, and the patterns used to communicate requirements to GPT became established, I was regularly able to get difficult, large pieces of the project completed in a few hours, which would have taken weeks using the most productive tools previously available. The engineering workflow is still the same - there's always a phase of communicating and gathering requirements, researching infrastructure, planning schema, logic, UI, etc., but all that is sped up by integrating every bit of it into conversations with the LLM, where the generation of code is all just a part of the same process - even the emails I write to communicate with stakeholders, IT staff, end-users, etc., all involve the LLM. I leverage the LLM every step of the way. This project currently has 35,000+ lines of production code which have been written from scratch, tested, and delivered to users, and the CRUD pieces automatically created by people using Baserow represent at least a few tens of thousands of additional lines of drudge code which would have had to be written manually, using any other highly productive framework tooling - and it's all rock solid, eliminating so many write/debug/test cycles, fatigue, careful detailed attention, labor, and frustration. Baserow automatically creates documentation for any entire database built with it, and GPT can immediate use those docs to build any required custom queries. That documentation is currently about 15Mb, for the existing Baserow database - so integrating the Baserow API is dead simple and is basically handled automatically and instantly by LLM code generation. It's hard to explain how much work that saves. And of course generating code to use an internal database, built in the custom application code (with SQLAlchemy, SQL, etc.) is just as easy and fast. What's really struck me in all this has been the painlessness of the work. Most of the hard challenges are gone. It still does take the same kind of patience, attention to detail, understanding about how all the parts in the system work together, as well as time spent setting up infrastructure, communicating with other humans, etc., but the difficulties associate with all those things, not least the code-writing routine, have really basically come to an end at this point, and I don't expect they'll return. GPT has guided every complex installation and troubleshooting routine related to standing up infrastructure (which in the past would have taken 100x as long, at every step), and I've used Gemini, Grok, Kimi, GLM, etc., whenever I've wanted an additional critical eye to help test and review code, evaluate vulnerabilities, etc., but the painful time-consuming work is dissolving very quickly. What's also been surprising to me is how well the most recent zip file technique I described above has scaled. From what I've experienced, I don't think there's an end to the scope of context which can be wrangled comfortably with it. This project encompasses several dozen separate custom applications in a suite, each of which would likely have been significant months-long projects in the past - all neatly connected, entirely malleable, adjustable, morphable, and manageable as needed, whenever changes are required. In fact, that's been one of the greatest improvements in my outlook - I don't hesitate to tear things down, re-integrate working parts with new features, etc. The LLMs are truly spectacular at re-forming and putting together pieces into new, larger, constructed works. I'm astounded at how successful these tools have been at building powerful systems. I've been using them all, in parts, for several years now, and among different incarnations of evolving useful concepts - but the progress in terms of capability and quality has absolutely exploded, even just in the past few months. My workflow is absolutely nothing like it was a 1/2 year ago, and it just continues to improve by leaps and bounds.

It's interesting, the only time I ever previously used any sort of auto-complete, or project management integration tooling, was with Anvil, because Anvil's tooling was a complete system - very productive because every piece was integrated (file management, Git versioning, visual UI layout, front-end code, back-end code (and calls to server code directly from UI code), database, ORM, code editor, etc.) and all of it was controlled with one integrated language interface, so in that system, auto-complete really beautifully connected all those pieces, in uniform way, which fit a very manageable, small mental model & language vocabulary. Objects throughout the Anvil system persist as lightweight references, so autocomplete in that environment is especially powerful. For example, rows from the built-in database, performed by ORM queries in back-end code, can be accessed directly by front end code (without any serialization to JSON or AJAX machinery, for example) - and those data references appear as autocomplete selections - consistently throughout the entire system. So you can perform a search on the backend, and those results appear as auto-complete choices in your front end code, and then they appear again in any back-end code which get sent from front-end, an so on... and since those objects are passed around as references, rather than as actual data value (as they are with serialized JSON, typically used in web frameworks with AJAX), they don't take up any significant memory (like pointers in C, but much safer/easier/high-level to use). That tight integration is a great thing to love about Anvil. But now I've moved on to even deeper levels of integration, and *much more powerful 'autocomplete', with LLM driven development, because LLMs not only complete the actual code for *all my engineering intentions (not just references to data, functions, and other labeled pieces), they also take part in communicating with clients, users, IT departments, etc., at the human level, as well as writing requirements documents - and reasoning, planning, chosen directions to satisfy those requirements, researching library and infrastructure choices, etc. Because all that activity happens in a single environment (the text of chat conversations), which the LLM has access to entirely - not just all the code, but a complete understanding of the real-world context of the application's purpose and goals, the environment it runs in, etc., it can help with every single piece of work that I do, including installing infrastructure, performing code review for pieces written by other developers, etc., etc... And at this point, the quality of code written by GPT is fantastic, and I can use other LLMs to perform code review, just as I would ask a team of experienced developers to perform code review, to uncover security issues, to suggest alternate engineering solutions, tools, code patterns, etc. I've never spent more than $20/month on LLMs (ChatGPT is the only one I pay for), and have never hit a rate limit at that expense, often using it all day for days at a time. For my needs, I've only ever used Gemini for free in Google AI studio, and the LLMs I have running on my little home servers are fantastically capable of generating quality code (GPT-OSS 20b & 120b, GLM 4.5 Air, and Mixtral8x22b are my favorites for cheap consumer GPUs), and bigger open source models like the full GLM 4.6, MiniMax M2, Kimi K2, DeepSeek-V3.2-Exp, Qwen3-Coder-480B-A35B-Instruct are as deeply capable as GPT, Gemini, Grok, etc. I still perform all the implementation of every piece of my projects -installation, debugging, all engineering decisions, tool choices, etc. by hand (as opposed to giving agentic systems access to a file system and command line tools, and letting them iterate automatically). Working with zip files in GPT makes that a piece of cake, and super fast, while still keeping me in the loop about every single choice made, every line of code produced, etc., directing every choice intentionally. I keep a full history of all the versions ever explored - reverting to a previous version is accomplished by simply unzipping a file already uploaded to the server. The decisions which went into every version, as well as all the code changes are fully documented in extraordinary detail in each chat conversation, which I store as a single .mhtml file - so reviewing everything that went into creating any piece of a project is super simple to track down - not just for me, but for the LLM too. I typically attach a single zip file which stores an *entire project and all related files (all code, resources, supporting files of any sort, user documentation, environment variables) - everything, in the exact file structure, as it exists on the server, and ask GPT to work with it, surgically changing/extending/integrating any features which need to built - always asking it to provide the complete updated code as incrementally numbered vXXX.zip files (i.e., v148.zip). I use SCP to upload those files to the server, where they're simply unzipped with -o (automatic overwrite). The LLM examines everything involved in the project, and can reason about how everything is connected. There's nothing from the project missing - and by using zip files (instead of cutting/pasting code in the conversation), GPT is able to perform absolutely massive context management. If the LLM needs more context about previous decisions which have been made, previous debugging steps which have been completed, or anything else about the history of the project, that's all contained in single .mthml files which can be attached to a conversation. Sometimes (rarely) I'll attach two separate zip files, for applications/projects which need to be integrated, along with multiple previous conversation .mhtml files, and GPT goes to work integrating the projects (it's update multiple zip files in a single conversation). I rarely need to type more than a sentence to provide all that context. The main reason I'm not using Anvil in this process, is that it's far more difficult to provide full context about the project, especially the visual UI and visual database management pieces of projects. It's entirely possible to work entirely in Anvil with code (and not use any visual tools), but all the LLMs are staggeringly proficient with Flask and the Flask ecosystem: SQLalchemy, SQL, other Python ORM tools, and any well-known tool in the Python ecosystem, as well as any well-known UI framework in the web development ecosystem - they are wizards at integrating solutions with those tools. Another important characteristic of everything in the Flask ecosystem is it's all super light weight and fast/easy to install on any operating system. There are basically no limitations to what can be accomplished with these ecosystems, and LLMs can help perform research and make informed choices about the best tools to fit any project goal - although they tend to use a simple core set of tools for any mainstream purpose: HTML/CSS, well known JS libraries, Bootstrap, jQuery (or choose React, Vue, Svelte, etc.) - whatever tools you prefer, as long as they are well known and well documented by millions/billions of pages of text and code on the Internet. Using the best known, most used, best documented tools in the industry is the key to successful LLM code generation.

I'm EXTREMELY grateful you are writing this all down. I appreciate it more than you can imagine. It's very interesting and quite astounding. I wonder, if it pleases you, if not ignore, what is the best way of setting up credit card or other payment systems processing and have you had any good experiences with with specific ones. You mentioned one. At some point in future I was thinking about making some how to videos and link a how to book and sell for low cost. If you can come up with a good video, and I think I could, then you could reach a lot of people and without needing a book publisher cut the cost super low while providing great value to the book buyer. I also was going ask what sort of power was needed to run these tools but you answered it in the post. I'm really happy you can run them on a laptop. The rise in computing power is just astonishing. Way back, very far back I took a class on IBM PC's. The original ones programming FORTRAN. AAAAAHHH! I hate FORTRAN. I also did some hexadecimal machine code programming on z80, same as 8080 intel, on a micro training station. It was interesting but think of the shear magnitude of what we have now in comparison. It's mind blowing. I also really like your comments on the AI scene and especially local AI's. I really appreciate all this scoping out these advances and giving your impressions of them.

Stripe has become the most common payment system. Shopify, WooCommerce, and other big ecommerce platforms are built on it, and there are endless integrations that make it really easy to get started. Anvil had a built-in Stripe integration, for example, and there are developer APIs for every language, common frameworks, etc. Paypal, Braintree, and Adyen are popular alternatives, and Square is common at physical stores. Authorize.net and old payment gateways are still around - jeez, I was using Authorize.net ~20 years ago. There are so many solid options. I did a big project for a medical billing agency a few years ago to make their existing payment system PCI compliant using a 3rd party API called Orchestra, while they continued to process with Payarc. That project involved using iframes for every visible entry field on payment forms, so none of the payment info ever actually touched my client's servers, even though the rest of the custom payment application was delivered by my client's servers. Users had no idea - it just looked like a single app, and enabled a way to satisfy those really difficult PCI compliance rules, for this custom system - PCI compliance obligations are some of the hardest to cope with! If you're just searching for a solution to take payments, stick with a simple to use system like Stripe, with capable API/SDK support - or build a store on a platform like Shopify. That makes it super easy and quick, secure, etc., and should handle 95% of most ecommerce needs.

Ask GPT, Gemini, Grok, Kimi, GLM, Deepseek, or any other favorite LLM how to set up a Stripe account, and then to provide the code needed to complete a sale of an item on your web site, for whatever language/framework you choose to build with (Python, JS, PHP, etc.). GPT will walk you through step by step, help you install libraries, debug, etc. You can also ask it to tell you about the benefits and drawbacks of any other payment system, if you want to use something other than Stripe.