Hacker News new | past | comments | ask | show | jobs | submit login
How Bubble bootstrapped a visual programming tool for non-coders to $100k/mo (indiehackers.com)
315 points by ChanningAllen on Nov 12, 2017 | hide | past | web | favorite | 113 comments

Wow this has been a disappointing discussion up to now, with most commenting on how much visual coding tools suck. That's not the take away here, at all.

A frequently asked question is "where is Access for the Web?", closing aligned with "what happened to 4GL languages and tools" or "where are the RAD (rapid application development) app builders for the web?". This is an answer; they've hit $100k monthly. They have found a market where many, many similar projects (I've listed them here before) have not. The relevant and amazing thing is how? How have they succeeded where so many others have failed?

The interview gives some answers:

He (Josh) was in New York, and everyone, literally everyone, was asking him to be their tech co-founder to start a business.

We started "recruiting" users at tech meetups in New York. With the startup wave, everybody was looking for a tech co-founder, and there were plenty of co-founder-dating meetups. ... We went there and told people that while we couldn't be their tech co-founders, they could use Bubble, as it would allow them build the whole thing themselves.

The following year (2013) we did a pilot at Harvard Business School, which I had just graduated from. Their first year entrepreneurship class required students to build something under a very tight budget, and Bubble was a good solution for this.

Answer; these guys had a kick ass network and expanded it. They had direct access to people in their market who were starving for this type of app.

TBH (and it is an impressive app) there isn't much competition, not much going on despite coding-as-a-job being hammered in every article even remotely related to education and not just an extra skill but a vital one.

And in those meetups you tend to find a lot of people looking for someone to code their ideas. These guys put a lemonade stand in the middle of the desert.

The question then is, what happens when they drink the lemonade? Thirst quenching? Butterflies and rainbows? Diarrhea? Cirrhosis?

When you start building a normally-complicated application that isn't going to be thrown away at the end of the semester, well, then what?

Perhaps the point of Bubbles is product validation for a semi-technical founder without having to hire someone who can code.

I've seen plenty of visual programming tools and lots of other things to help "non programmers." I've even helped build one.

The fact is that if you can think and communicate precisely enough to describe your ideas then you can enter them into a computer fairly easily in a language like python or basic. If you can't then no matter how fancy your tools are you still need something intelligent (currently a human programmer) to pull the idea out of you and encode it.

Stuff like this isn't useful to people who are incapable of programming and is just a highly coupled mess that can't be easily automated and version controlled.

I think the problem is once you get into coding it yourself, docs/tutorials/stackoverflow make you aware of all sorts of things like dev tools (IDEs, editors, package managers, VCS, VMs, containers, the list is goes on...) or security concepts (csrf tokens, ssl, secrets management, again the list goes on...) and as a non-tehnical person you start to get really uncomfortable and overwhelmed because you don't know what all this stuff is and you don't know which things are necessary to learn and which are "nice to haves" to build something simple. So you either give up or you try to learn as much as you can about these things. But learning about these things is a slippery slope because before you know it months (or even years) have gone by and you're no closer to shipping that simple idea you had. Sure, you've learned a ton! You may have even learned enough to get a junior dev role somewhere which is great! But you never finished that original thing you were working on which IMO we need more of. We need less people getting burnt out in dev roles after 5 years because that's not really where their heart lied in the first place and we need more people finishing the projects that got them into coding. Not saying Bubble or any of the other visual programming tools are perfect but I think saying people should just learn Python and Django and code it themselves ignores how complicated that path actually is and how few people actually go down that path and get their ideas out into the world. Anvil.works was on here recently and I think that strikes a nice balance. It's not perfect either but I guess I'm just saying I think it's great people are working on stuff like this. And, as mentioned in another comment, this thing has a $1.2M run rate. Clearly it's useful to someone.

Are you saying sane and secure defaults in Django or any other web framework should be enough for a beginner to not have to to worry about this stuff? See another issue for beginners trying to figure it out is they have to deal with people online who post 6 links with no explanation as if it's SOOOO obvious.

This is not a tutorial and he/she is not answering to a beginner. A description would have helped nonetheless

Thanks. MechanicalTwerk, I meant this is how to make that slope less slippery and steep. They're software design patterns -- going with principles and paradigms, like https://en.wikipedia.org/wiki/Structured_programming

Agreed that design patterns and just thoughtful design in general can help create frameworks that are easy to get up and running. I guess what I was getting at is that a non-coder could probably stay completely in the browser, maybe even completely on the bubble.is site (bouncing back and forth between the docs and the editor) and have a clear path to launching an app that they can feel comfortable knowing is secure and will probably perform well enough. With Python and Django, they'd have to cobble more things together and the risk that they end up going down some rabbit hole that doesn't quite have to do with their initial goal is greater.

> stay completely in the browser [focusing on] ...their initial goal

I believe this is worthwhile long range target that we can build up to on solid foundation, such as component oriented software. As the pieces come together, the harder fought wins that use and prove its foundation early on will pay off greater, later.

> This is not a tutorial and he/she is not answering to a beginner.


Do you know any other such website? I found these explanations useful.

Came here to say this. But then realised my wife.

She did a year of com sci. She learned SQL at work. She can Excel with the best at her bank, with some VBA here and there. Still I had to coax her into learning Python for some bigger-than-Excel datasets. She wanted to for ages but just couldn't make the leap to "real" programming (her thinking, obviously not true).

Even when she tried we had issues installing things. She made good progress and almost got it. I sat an evening with her and we solved the issue. She had a lot of support to get over the various hurdles, support many don't have.

Obviously it's one data point but it highlights the issue. I think we've forgotten how hard it can be. Anything that helps should get a shot.

This is great, thanks. I think the issue is, things quickly turn bullshit.

Programming math is high school stuff, but imperative programming is bullshit. Memory leaks. Exceptions. Callback chaining. Asynchrony. Model-change listeners. Spooky action at a distance. Legacy interfaces.

Functional programming fixes all that.

Programming excel is college stuff. RDBMS is bullshit. JOIN pain, batching vs caching, ORM, pressure to denormalize for performance at scale, eventual consistency at scale. Non-RDBMS solutions generally make sacrifices regarding ACID vs consistency vs performance. Bullshit.

Immutability in the database fixes that too.

Forgive my imagination, but an immutable database sounds pretty useless.

Useless like git? :) Immutable here just means append-only. If old history is fixed it is really easy to have pervasive caching, which helps make chatty queries faster (e.g. solve N+1 problem)

Well why not say append only?

Why? Just create a new db if you want to make a change :-)

I can think of field where these kind of tools flourish: music and art. I'm thinking of this specific counter-example:


There may be other specific problem domains where subject matter experts may be able to be productive, if given relatively basic programming tools along with specific, modular, abstractions useful to their problem domain.

I could see drone programming becoming something like this - a farmer may need to update his drone behaviour every day, but he may not be excited about learning to 'program' it.

People may be capable of programming, but are not programmers.

They do some other full time job and can't invest 2000 hours per year for 5 years to become efficient at all the detailed things the programmers have to deal with.

The use case is people who can excel at Excel, but don't want to learn about dependency injection, semantic versioning, exception handling etc.

If you can excel in Excel, you certainly can do similar jobs with Python. You don't need dependency injection, semantic versioning (any version control at all!) or exception handling to write a script that turns your data from format A to format B and generates a summary. Most people can probably learn enough Python to do that in two or three weeks.

There is a large gap between what professional programmers are expected to know and the minimum skillset needed to write programs that are useful for one specific task. Many people in your typical office would benefit from the ability to (partially) automate some of the tasks they do every day. Implying that they have to invest countless hours to learn how to do that is part of the problem.

There are lots of people who do elaborate things in Excel. I'm sure they could learn Python, but they don't and won't. Instead of changing the people, consider that maybe what they want/need is something like Excel but more powerful.

But Bubble doesn't seem like an Excel but more powerful.

This. The difference between python and excel is that excel functions at the same time as an IDE as well as data prototyping platform.

iPython (or is it Jupyter now) notebooks sound better suited to the task.

I've known a lot of people to end up using Excel simply because it is the only "programmable" application that is available - if you can't install new applications (which is pretty common in many non-developer environments) then you are stuck with what you get installed for you, which in many cases is Excel.

Python is great, but if your goal is to build a simple web app, there's no simple, pythonic way to do that. Maybe anvil.works will be that one, but currently, there's a hole in the market, and bubble fits this hole very well.

This and I would go one step further: visual programming tools are like GUIs and they are the main reason that people can't code nowadays.

When I switched back to a shell after 20 years I realized how much a GUI hurts, how much I unlearned to work with computers. After decades of Windows and OSX, I got Arch with i3 (so no desktop environment). I am mainly using text-based software like the shell, bash, tmux and vim every single day. Then, it's a very small step to program or to get a programmer because you are already programming in little steps here and there and every day (bash scripts, vim macros, etc.) and you deal all the time with text.

Visual tools don't teach you to code, they introduce an unnecessary layer and create an even bigger insecurity when dealing with real code. Real coding with text is quite easy—and this should be the actual message. A very good example for an educative text-based coding environment which is even functional is Logo. But again, the best way to get into coding is to get an OS on your personal computer which focuses on the shell.

I'd go a step further again and say that GUI's are why people have no idea how to use computers anymore. A file is a concept the average user is becoming less familiar with, directories of files have almost disappeared entirely for them. The idea that you could manipulate an image in a paint program and have it updated in your word document is black magic, so tools like word and excel have to do everything they need.

A story I've told before is my mum and the software that comes with her digital camera. This software is everything to her, if she want to back up the pictures she uses this software, if she want to print them she uses this software, she has no idea that the individual photos are just files on a disk. So what happens when she get's a new camera from a different manufacturer? Her knowledge is back to square one and she has to relearn all over again, this is what infantalising users has lead to.

People know how to use computers just fine. Very few people need to know how the programs they use are implemented, or even the data structures they use. For most people nowadays, computers are for playing games, sending and receiving mail, watching videos, reading the news, shopping, and organizing your photograph collection. You don't need to know how to program to use a modern computer.

Also, whether photographs or anything else use files stored in hierarchical directories is a historical accident. There are alternatives to file systems. For example, Squeak doesn't have files, hierarchically organized or otherwise, just persistent objects. EROS also took that approach.

A file is just an abstraction at the end of the day. The hardware knows little more about a file than an ignorant iPhone user.

"Visual tools don't teach you to code, they introduce an unnecessary layer"

I disagree. The main benefit of a visual tool (if implemented correctly) is that it exposes the constraints and the tool grammar to the user when implementing and not only when compiling.

The difference is more or less of that with clay, and lego blocks. Yes, you can design a house with both (Lego house). Clay offers an infinite shape grammar, but if all you want is a lego house, then Lego blocks are much faster.

Now, is the visual tool a cognitive crutch, or a bicycle for the mind, is another matter entirely.

GUI or no GUI, apparently, people can either program or not, and it's been this way since the '60s, at least.


The paper that post was based on was famously retracted: http://retractionwatch.com/2014/07/18/the-camel-doesnt-have-...

I see. I'd still posit that I don't think GUI usage and programming aptitude correlates. But, all the data I have is anecdotal.

I think this is a big case of cognitive bias (and get-off-my-lawn-ism ;) ). It's only a small step for you between using a text-based Linux and coding because you've already taken the huge frontload of internalizing the mountains of cognitive load and neccessary, but ungeneralizable knowledge that bash, vim & co. bring with them.

Coding with text is easy, but then why we there is a gap between getting a prototype/design done and the actual implementation? Text based coding is certainly more efficient in representing logic in a concise way, but the current set of frameworks and tooling on text based environments requires an exhorbitant amount of learning to produce a working application(e.g React), that's where the rapid application development tools like bubble comes in. In my opinion a combination of text and GUI should work together to provide the best possible efficiency for developers and other members of a team..

> why we there is a gap between getting a prototype/design done and the actual implementation?

I think this has rather psychological reasons. There is a good book from Seth Godin called 'The Dip' which deals with the problem why most are fast in prototyping but not able to transform a prototype to an actual implementation ('to stick to the end'). However, I think there is nothing wrong with a prototype to fully-implement rate of 100 to 1. Prototyping is how people learn as well.

Moreover, I am not saying that GUIs are per se bad. If I create vector-based graphics I need a GUI, when I browse the web I prefer HTML/CSS and a GUI's smooth scrolling over a text-based Lynx. Some programming languages like Java are better with GUI-IDEs but my main point was another one: That too much GUI in your daily life creates an unnecessary intimidation towards programming (if you are not a programmer yet).

That's could be because we are accustomed to coding through text. Imagine asking a designer to use code for vector editing?

> Text based coding is certainly more efficient in representing logic in a concise way, but the current set of frameworks and tooling on text based environments requires an exhorbitant amount of learning to produce a working application(e.g React)

That's a problem with this particular set of tooling then. In the past we've had drag'n'drop tools like visual basic which made rapid prototyping easy and you'd use the same tools for the final version. On the text side you've got similar tools like Qt and Gtk which allow you to slap together a prototype quickly and then use them for the final application. I always assumed react was quite similar.

> Coding with text is easy, but then why we there is a gap between getting a prototype/design done and the actual implementation?

The solution for this is simple, really: simply declare the prototype the working implementation, and put devs on the hook for maintaining it.

Don't see why you are being down voted. That always seems to end up happening.

By prototype, I meant static prototype or the visual design in tools like Balsamiq.

> visual programming tools are like GUIs and they are the main reason that people can't code nowadays.

Lots of people can't code, and most programmers can't code well, yet very few people have been exposed to visual programming tools.

I'd look elsewhere for explanations:

(1) If those with more aptitude for programming are more likely to become programmers, and the demand for programmers increases, programmers with less aptitude have to be hired. (And the problem is made worse by excluding experienced older people when hiring.)

(2) Whatever the reason, very few women become programmers now compared to the past, so almost half the population is being excluded.

(3) There's less diversity in software now. There's only two operating systems (with the same user interface), and only imperative languages augmented with object orientation, mostly with C syntax, so programmers only learn to think in one way.

(4) Personal computers nowadays are basically appliances which you can just use without programming, and that's what most people do. When they first became available, there was very little software on them and a far greater incentive to learn to program so that you could make them usable. For many people back then, programming became an end in itself.

> Visual tools don't teach you to code, they introduce an unnecessary layer and create an even bigger insecurity when dealing with real code.

There are different kinds of visual tools. Some visual tools (like, if I'm not mistaken, Bubble) are code generators so aren't designed to teach you how to code. Others are programming languages in their own right with no textual substrate, so there's no extra layer.

It isn't as if you need visual tools to introduce unnecessary layers anyway. There are now frameworks and other unnecessary layers, which of course mean you need more programmers to handle the additional complexity, and then you have problem (1). If the software industry designed aircraft or bicycles, you'd never be able to rotate your plane or ride your bike uphill.

> Real coding with text is quite easy

No it is not. Programming is hard however it's done, even visually. Concurrent, type-safe programming is even harder, and it's here that visual dataflow programming would help. MIMD programming is problematic in textual languages because there's an explicit ordering of operations, and there are synchronization issues which have to be addressed. Switching to the dataflow paradigm avoids this, but dataflow is difficult to express in text. Also, textual languages make type inference and code optimization harder.

> A very good example for an educative text-based coding environment which is even functional is Logo. But again, the best way to get into coding is to get an OS on your personal computer which focuses on the shell.

I agree with you about Logo. But Logo originated and was closely associated with the Lisp community centred around MIT, which had a very different way of doing things from Unix approach you seem to favour: a listener instead of a shell, multiple windows, and a programming language very closely integrated with the operating system.

"fairly easily in a language like python or basic" - I don't know where to start but I can say it goes deeper than that. A language like python or basic might seem simple to programmers or computer science graduates who learned their way through C, C++ or Java, but for a non-programmer, who is still tech savvy (like designers/business analysts etc), it is a complete different experience. How did i know? I had friends who can hack in visual basic, but can't do the same thing in Visual C++ (both are different species despite the visual prefix), even if given 4-5 times more time, or sometimes they really can't do it. It could be the initial barrier of entry that turns them off due to the sheer amount of time required to be invested to get the "know-how" or the just the sheer complexity in getting basic things working.

There were lots of people who can build small to medium complexity apps in Visual basic in those days when VB5/VB6 was active (Pre C#/.net). Even as a developer I was happy to hack in VB any day than VC++. But any developer I knew back then wouldn't touch VB, claiming multiple reasons ranging from "not powerful", "no performance", "messy" (don't know what that means) etc. It was like developers wanted to be associated with complex languages in order to have a respect among the community. True, VB performed slower than VC and even lacked few capabilities (like you can't write a device driver or difficult to write a custom COM component etc), but it was perfect for writing business applications.

Not sure what destroyed VB, but I believe it was the web that changed everything. Java and .Net though are well designed and powerful, but they bring a lot of complexity, requiring new developers to spent considerable time to gain even a basic knowledge. With the advent of SPAs things went even worser, current SPA frameworks like React and Angular are adding layers upon layers of complexity to build some basic stuff.

IMO if you can hack a UI in a prototype tool like Balsamic, then you should be able to make it a working prototype within at least 2-3x the time you took to prototype it, including binding dynamic data from a web service. If in 2017 we are still taking 3-4 months to build a basic website (dynamic) or mobile app, we have failed somewhere.

Projects like Bubble are providing stepping stones towards a possible future where we can build UIs almost as fast as we can imagine/sketch them in a prototyping tool.

I agree. And I think Anvil is an even better "modern VB" than Bubble: https://anvil.works/

> if you can think and communicate precisely enough to describe your ideas then you can enter them into a computer fairly easily in a language like python or basic

Try "thinking and communicating clearly and precisely" the process of multiplying two numbers larger than one thousand, in Roman numerals.

For me, it was very difficult if I didn't cheat and implicitly convert everything in my head to normal (Hindu) numerals first.

Now, try to do the same thing with Babylonian numerals (base-60).

(I tried and gave up)

What I'm trying to illustrate is that the tool you use to express an idea, imposes a hard limit on how "clearly and precisely" you can think about that idea in the first place.

Hindu numerals are one tool (one notation) that make processes such as multiplication and division easy to express. If such tool wasn't invented, we'd be spending too much time 'thinking' and 'expressing' and 'teaching' multiplication, and be left with too little time to actually benefit from it.

The Romans themselves didn't multiply Roman numerals. They used abacuses. Roman numerals were just the initial inputs and final output of calculations.

I think that helps the point that the wrong notation (ie interface, eg Roman numerals for multiplication) can be prohibitive to making sense of and processing data.

I was working back when CASE was the next big thing. People have always loved the idea of programming with pictures. But after decades without success I think we have to acknowledge that paradigms like spreadsheets, Trello etc. are the real way that end users build computer systems.

I couldn’t agree more — text just makes sense. All tools suck for some reasons but we all learn ways of dealing with them. Programming with text has issues but the power it provides is worth it and learning to deal with those issues only takes a few months.

I’d like to point out that 100k is not a lot in this market. Dev tools are an 11 figure market with tens of millions of programmers. I think the biggest change is the surface area has grown so much that the failed visual tools of yesteryear might have been able to carve out sustainable markets today. Bubble, Webflow, and Square Space can all be succeess stories but that doesn’t mean they’re a bellweather for all of coding. There are clearly a lot of small problems (simple web apps) business needs solved that are simple enough for these tools. I say hallelujah! Now I don’t have to update the pricing page every 3 days and can work on the real problems! The only caveat is to keep everyone in their swim lanes and don’t let the wise Bubble intern shard my database.

Agreed. My day job revolves around "visual dev tools" like VVVV, Reaktor and Unity/Playmaker, and "Should I use a GUI or a scripting language" is rarely the issue. I've seen Art Students learn the basics of C# rather easily, same for the java dialect used by Processing.

The biggest issue are always the skills required to bring their ideas into actual code. Most of those tools still require an extremely advanced knowledge of calculus, DSP theory and linear algebra. Imagine if a fashion designer wanted to display a set of generative images displayed in the background following the catwalk ground vibrations (this was a real request). Even if he/she could accurately describe their idea, that would be still several magnitudes outside their STEM Skills. Most of the times we end up hiring an external dev who will be forced to use such visual tools, making his job even worse.

I agree. Typing is not the hard part of programming.

Typing wasn't the hard part of using shells, either, and yet GUIs have displaced them for many classes of users. One of the very hard parts is "knowing what things you can type." GUIs solved that problem for UI much better than shells did -- it was much easier to discover what the computer could do in an early GUI. A good visual programming language (not that I've seen one yet) could bring similar discoverability to programming.

I don't know, most times it is much quicker to do `--help | grep something` or similar than clicking through nested menus with limited or no search

Still, a cross-platform GUI / VPE (visual programming environment) like this or https://glade.gnome.org/ might help for UIs.

> Stuff like this isn't useful to people who are incapable of programming and is just a highly coupled mess that can't be easily automated and version controlled.

You might be right, but they're still making over $1mm/year in revenue.

A visual node based computation graph editor is nice when crafting 3D shaders, if the substrate is rich enough such that the number of nodes to visualize remains comprehensible.

I watched the demo video. It looks like what the Visual Basic form builder was for Windows programming in the 90s.

However it will be difficult for non programmers. The very first dialog about Google Maps has menus "API provider" and "Query". I wonder how many non programmers know what they are. They can take a guess and learn but maybe this is still too low level. The second example is about building a login form by configuring its input fields. Maybe adding a completely configured dialog would be good enough for non programmers. Programmers can edit the details. Same for every other component.

However I remember that non programmers didn't use Visual Basic, as easy as it was. Programmers did. Some non programmers built sites on MySpace some 10 years after VB, then wrote on various blog platforms and configured themes, then ended up on Facebook and other non programmable social media platforms. Outside the Web the most used non-programmers programming tool is still probably Excel. I've seen amazing stuff build there from people who couldn't write a two lines script in Python.

Your comment sounds like something straight out of a Show HN, not a thread about a 5 year old service with 100,000 users and $100k in monthly revenues.

There's obviously a big demand for this so either you're wrong or people using it are actually programmers.

I just took a quick look at it and GP has a simple misunderstanding here. When they say you don't have to be a coder that doesn't mean the target market is my girlfriend who has no interest in this whatsoever(she's a doctor).

The target market is those people that sit in places like the AWS loft or places like that, listen to tech talks and wish they had a coder to build their ideas for free.

Most of them already know what an API is. Even if you don't use the external data sources, what bubble provides is somewhat enough to win hackathons and get funding provided you can present and sell.

I've seen a bunch of traders, business people and otherwise people with random ideas that fit in that group. So yes, not at all surprised they make that much money.

From the people I've met in start ups so far, the most likely to use it would be Designers and Product people. The Product manager I work with knows what an API is, and could probably hack out a solution to something, but really prefers not to.

At what point do you call someone a programmer? They seem to be using "knowing how to code in a traditional programming language". However, I would not use that definition. Most of what we do though is thinking about a problem and how that relates to what computers do. My take would be that everyone actually using this tool either is a programmer or by the nature of what they're doing soon will be.

> Most of what we do though is thinking about a problem and how that relates to what computers do.

Ah... now, in my mind, you're getting into Software Engineer territory. Programmer, to me, simply means you know how to make a computer do what you want. That can be "knowing how to search for someone else's code that makes the computer do what you want" at times. Once you get into thinking about the problem and how that related to what computers do, you're getting out of that generic "programmer" term and into engineering.

I'd call my 7 year old C= 64 hacker self a programmer. The real distinction comes from being a professional or not.

If you are a pro, you would know the industry, the hardware, how things communicate, how and why to scale and report things at a higher level, because you've been exposed to the needs and wants of an Enterprise.

> people using it are actually programmers

Kind of wouldn't surprise me if the user numbers had a decent sized (probably not majority) programmer contingent; these kinds of services are a good way to get a quick prototype out, before you legit build something.

I agree. I've seen people discussing sketching out an MVP with Bubble.is and I can see how something like this could be useful to put together a demo.

I can imagine that this does appeal to programmers as I imagine some companies have already built internal tools to the same affect for rapid prototyping.

Programming isn't a mystical art that only a few wizards can learn. Millions of people write software to help themselves do their job in things like Applescript, VBA, Google Forms, etc every day. You don't need to have the title "developer" to understand and write code, even if the actual "code" itself is a few layers of abstraction away.

I agree.

But while not "F U money" $100k p/m is enough to say: Well someone must be using it then.

Perhaps, in the Hooked sense, the somewhat diffcult learning curve helps to increase long term retention?

How do you know it’s not FU money?

On annualized turnover you need at least one or two more zeros to reach F U status :)

I agree. Bubble is way too advanced for non-programmers to just “pick up”. I am not a programmer but worked as a product manager for several years and consider myself technically knowledgeable (can copy and paste basic code, I know how an API works, I can write basic scripts, basic html, I understand conceptually things like oauth etc) and I found bubble to be basically incomprehensible. I could probably learn it if I was willing to dedicate some serious hours to it, but for the business I am in (founder of a marketing agency) it’s much cheaper for my to just hire a programmer than to dedicate several weeks/months to learning bubble. I hear it’s great for programmers to speed up their workflow though.

> However it will be difficult for non programmers.

I work with non-programmers every day who know what APIs and queries are.

There are millions of people who are technical enough to manipulate Excel sheets, talk intelligently about API integrations, and tweak SQL queries but are not programmers themselves. Non-programmer does not automatically mean non-technical.

I've seen people that used Excel every day for decades and didn't know there was something like the '=' that displayed the contents of one cell on another.

They used it just for the tabular form.

But I agree with you on everything.

Maybe http://anvil.works would be better ? Going through the tutorials they have an intuitive interface.

I had to learn and use Bubble to build an application (no choice, per client's request) and as a programmer I found it to be a nightmare.

I can definitely see it as a great and useful tool for non-programmers, but having to go throw your entire skill-set and decades of knowledge out the window to use a tool like this was just a horrible experience.

Again, I don't mean to disparage it, as I can see the benefits, but for programmers, you're better off building an app with the skills and knowledge you already possess.

There's something like an 'uncanny valley' between RAD tools and a more 'best practices' setup/workflow.

The upsides are obvious – someone that's not a 'software engineer' can program things that do real work!

The downsides tho are much less obvious; more 'hidden' costs really. It's easy and quick to bang out a new feature, but also really easy to inadvertently update or rollback another unrelated set of changes. As a professional programmer, I sure don't want to give up version control, unit tests, integration tests, automated builds, and automated deployments.

Tho in fairness to RAD tools, and both the code they produce and the whole workflow involved in using them, when I started my current position the non-RAD-tool code was (much) worse, and much more difficult to refactor and cleanup, than the RAD-tool code.

As a marketer, I've found Bubble to be really useful for building out small micro-apps for data-capture for clients who for whatever reason weren't ready to move to a solution like HubSpot.

I'm not sure how I'd feel about using it for anything larger than that, though I've seen some worked examples of Twitter clones etc. There's probably slightly too much Bubble-specific terminology and concepts to make it worth learning if you are not going to become a Bubble consultant.

Also, kind of expensive (monthly subscription) if you want to run a large production app on it. I love the range of API s and connectors though.

It sounds like the "remedy" for app dev.

What I'd really like is a smarter compiler. My normal dev process is

1. Write code

2. Run code

3. See error

4. Google error

5. Write code to fix error

6. Repeat

I'd like a compiler that helps speed up steps 3-5. I know IDEs do some of this, but I'd like a compiler that automatically fixes errors instead of just telling me what went wrong. One that fixes parentheses that I left off or automatically fixes typos in variable names or function calls. One that knows to keep things DRY and creates a function for me when it sees the same similar code written twice. One that knows when I wrote an inefficient bubble sort and swaps it out with a faster sorting algorithm etc. One that can make my code run faster. I think this is a long way off, and I know it's really hard to write a program that writes code, but it's always seemed that programming simple things is way harder and takes longer than it should to me.

Typesafe languages are potentially a lot better here; they move "see error" to before "run code". Visual Studio or even Eclipse are quite good at inserting parens or quotes for you, warning if they're not there, and providing completion over identifier names to avoid spelling errors.

> One that knows to keep things DRY and creates a function for me when it sees the same similar code written twice

This is potentially an interesting idea.

> One that knows when I wrote an inefficient bubble sort and swaps it out with a faster sorting algorithm etc.

This is also the sort of thing that optimises out your security-critical delay loop or memory wipe.

It wouldn't overwrite your code without your approval of course, but if it could at least provide helpful suggestions that I could choose to approve it would be immensely helpful.

Which language are you using? IDE or no IDE, it's been a long time since I've used a language that doesn't get statically analyzed or linted while I type. E.g. Clang statically analyzes on the fly in Emacs. I certainly don't need to Google any errors as the error messages are helpful.

Some of the other stuff you mention is not a way long off if you use an IDE like Visual Studio, which, with or without Resharper does a lot of code analysis. You get notified if you have dead code (branches that never get ran), duplicate code (i.e., things that should be turned into a common method or class), etc.

One that fixes parentheses that I left off or automatically fixes typos in variable names or function calls.

Webstorm can do some of what you mention:



One that knows to keep things DRY and creates a function for me when it sees the same similar code written twice.

Unfortunately this is "sufficiently smart compiler" territory. I'd love to be wrong about that though.

You can use Javascript, the main engines will do that kind of magical "fixing" like adding missing semicolons and hoist variable definitions upwards in functions. It's even transparent. It's an hot mess.

What you request in the last paragraph is a Junior Developer to do the grunt work of implementing a spec.

I'm not sure why this has been down voted, but what you are describing as "magical" were a direct consequence of the "lazy" or "lackluster" language implementation. Semicolons are optional, and variable scope is not strictly lexical. This can be seen easily by implementing a javascript subset, which is an interesting excercise. Specifically, the part where you build symbol tables and do symbol resolution. These are also some of the reasons why Javascript is derided by many.

Am I right in understanding that Bubble is a GUI for building CRUD applications?

If so, great work! It shows there is a need for these simple, automated tools for building simple CRUD applications, and that it is possible for these to be built and automated.

We have had MS Access for years. It still requires a bit of knowledge about database design to use it properly.

I don't know Bubble but I am skeptical about visual programming, as syntax is one of the easier parts to learn when coding, and isn't in my opinion what makes our profession difficult.

IMHO visual programming should really aim more to be a scaffolding tool - so instead of replacing the syntax to focus more on speeding up the structuring of the code, helping you to easier manage and understand the blocks and the flow. Ideally it can then auto-generate the most of it and leave you to fine-tune the details of logic directly in the code (where it's faster and more expressive to be able to type the code directly).

Also if it's not in text, you can't use all the tools effectively, like diffing, versioning, to actually create reliable tools with few bugs. I'm very skeptical of graphical programming.

Unfortunately, there's a long history of graphical programming being foisted upon text-centric domains, which is just as bad as the reverse, so you're right to be skeptical. But if you shift perspective to another domain, graphical (or otherwise non-textual) programming becomes much more appealing.

For example: Game devs build themselves sandbox environments in which they can test out their physics engine, dynamic music systems, animation playback, etc. These sandboxes are like REPLs, but for non-textual data. One can imagine how much nicer it would be if the full system's code were represented first-class inside that sandbox, so that you were introducing and manipulating system abstractions close to the truest representation of the data, rather than having to leave the sandbox to go back to your text editor to make system tweaks, far away from the data.

Still skeptical about why that might be nice? Your text editor and terminal know nothing about the full, live representation of the data, so they do nothing to help you work in that domain. The nice things you get when working with text — diffs, versioning, etc — you don't get the physics engine / music engine / animation engine equivalents unless your code is somehow present in the same space as the live data.

Totally agree. LabView control structures become unwieldy messes of spaghetti quickly from what I have seen. Visual programming is good for some niches in electrical engineering, for example, RF processing chains. But trying to use it for general purpose programming seems to lead to more complicity, not less.

Bubble platform is the most advanced no-code tool that exists so far. It allowed many entrepreneurs (including me) create apps fast and with low budget which otherwise would take many months and tens of thousands dollars to build. It's true, I'm a bit biased here, because it also became possible for me to start a no-code development business which never existed before. So we focus on building apps without code for people who don't have time or patience to learn the no-code tools or who don't have budgets to afford the traditional development. And for the sceptics that doubt about the complexity of apps that can be built without code you could check our portfolio at https://bubblewits.com (this web-site is too built on Bubble). But we have taken it 1 step further and created a no-code platform for all things no-code. The main part of the paltform are the no-code templates built for Bubble. Which makes building new products and startups even faster (just like creating a web-site with Wordpress themes is easier than doing it from scractch). If you are curious take a look here: https://zeroqode.com

So you guys are a service that build apps on bubble (for people that I guess can't even deal with a GUI) and also sell templates?

"Josh and I both had enough savings from previous jobs to be able to live in NYC for more than two years (with a simple lifestyle…), and we didn't start paying ourselves a salary until 2.5 years in."

Critical factor here.

Has anyone had experience transitioning a Bubble app into an actual coded app/DB outside of Bubble?

I could see it as an interesting solution for rapid prototyping of ideas, but I'd be concerned about lock-in and extra expense later when migrating to something more robust.

Based off the demos, it seems like you can integrate HTML directly, so it might be possible to move from Bubble to "external API + Bubble frontend" in a straightforward fashion.

You could also likely put a layer in front of Bubble to only serve some pages with Bubble, other with your replacement.

Also from the FAQ: > The good news is that Bubble is fully extensible via Javascript plugins. The Bubble model is to write the core website functionality using our super-simple language, and plug in Javascript to handle algorithms that are hard to build in Bubble.

So you could probably add shims and move around.

I think the most interesting way of doing this would be something like embracing Bubble for a lot of work and having the "serious" code relegated to places that are easier to manage, like complex API or some custom widgets

> I think the most interesting way of doing this would be something like embracing Bubble for a lot of work and having the "serious" code relegated to places that are easier to manage, like complex API or some custom widgets

This is basically what I do now at work. I was hired to, in part, work with several RAD-tool projects. I pretty quickly ended-up tho working on mostly backend code that the RAD tool projects interact with via, e.g. web requests. That's been a pretty good division of labor given that most of the RAD tool project's features are fairly simply in terms of UX. They're definitely not good enough to be widely used by lots of users tho, e.g. there's no real error handling.

>> The Bubble model is to write the core website functionality using our super-simple language, and plug in Javascript to handle algorithms that are hard to build in Bubble

Programming without code...until you need to actually do something

^ This. I'm writing Bubble off as another hype-ster toy until proven wrong.

For a similar idea, but more aimed at programmers, there is Anvil: https://anvil.works

I tried them both and (probably obviously as a programmer) find Anvil faster to work with. Some things are really fast in the visual environment, but when you are stuck, getting code out is really convenient. I do like both approaches.

I'm very pessimistic of these types of products.

Mostly because there have been ideas to do this for around 40 years.

In the end any non-trivial business logic is too cumbersome to make in a GUI and is build much faster in text form ( programming language) or just can't be made with your platform. At that point it requires specialization and your need for a programmer is born.

> I'm very pessimistic of these types of products.

> there have been ideas to do this for around 40 years

You should be "pessimistic" – if the implied claim is that "these types of products" will replace all of the other standard programming paraphernalia!

But, as you wrote, this stuff has been around for decades. And that's because there are lots of people that can do real work with these tools, but aren't otherwise willing to pay the (pretty) steep costs to get up to speed using the 'pro' programming tools.

I found this product awhile back and was so excited at first.

I have a design background ( but can dabble in css, hack at php and python) but had trouble trying to get some APIs connected and displayed with Bubble.

Please oh please, can one of you developers have Airtable and Webflow make a baby? This combo would be amazing for functional business use and data display and I would pay good money for it.

I agree — as someone with as much of a design background as a programming background, seeing something like Bubble described as "visual programming" feels a bit offensive. Yes, there's a bit of meaningful visual structure sprinkled here and there throughout their environment. But it's nothing like what one would imagine if they were left to freely ideate about some hypothetical, ideal "visual programming" environment.

In a post-Bret Victor world, we know what such an environment might look like.

Stop Drawing Dead Fish: https://vimeo.com/64895205 Drawing Dynamic Visualizations: https://vimeo.com/66085662

As a visually-minded developer constantly hunting for such tools, and even working on some myself (in a small way — nothing that anyone here will ever end up using, surely), I can assure you that there's enough smoke that eventually we'll see something like what we desire catch fire.

If I had to guess, I'd say we'll see it come out of the world of video games, not web applications. So don't fret that Bubble looks like a step in the wrong direction. They're not building tools for visual thinkers, they're building tools for MBAs.

I just wanted to check out the website (not actually try it), but the Bubble page shows a blank page saying it doesn’t support my browser (safari on iOS). What a pity that it won’t even show me a landing page or whatever.

"Then, in October 2105, we launched publicly on ProductHunt"

I'm guessing this should be October 2015, but it'd be awesome if Bubble was a product from the future sent back in time.

yet another LightSwitch. with better marketing

Keep it up!

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact