Effects on success: I already knew this stack (no time lost learning new tech), can run with a very tight budget (suitable for starting a business on the side). And, obviously, this is a great stack that will scale far into the future if needed.

https://broadcast.listennotes.com/the-boring-technology-behi...

- I use Redis with Celery instead of RabbitMQ (not because it's better, but can be picked for other usages like caching, etc.)

- I use Heroku to ease deployment instead of having to deal with servers (but I'd like to add serverless to my stack, Heroku is not optimal for SPA deployment)

- Angular instead of React (mostly because at the time, I absolutely wanted to use Ionic)

Effects on success: fast to run, very reliable back-end, no need to be expert in Javascript and tooling (because angular/ionic is very opinionated)

Bad effect: need to deal with 2 languages in parallel can be exhausting sometimes.

I've been working on building out a productized offering of a starter kit for this stack: https://www.saaspegasus.com

Would maybe add Docker (without K8s or any orchestration).

I trust it and use it every day.

When starting from nothing, these were incredible platforms. Features like the OS, web server, memcache, taskqueues, databases, startup-scripts, emailing, and auto-scaling were all built-in with almost no configuration.

The PaaS wave has pretty much come and gone. Now you need to think about and choose your linux image. If you want memcache, setup your own Redis server. For taskqueues, you need to master RabbitMQ. For email, sign up for Sendgrid or another service. App Engine still exists, but they keep stripping features from it, and push you to standalone services.

When you get very large, you'll likely need to migrate to these more tunable services eventually, but when you're just starting out, it's a huge boost in productivity to have these basic services available that just work for a large majority of use-cases.

My guess is that most of the PaaS users were smaller companies / solos that didn't have the bandwidth to manage all these services and also build their app, and I suspect many operated in the free tier. Google probably recognized they weren't making money in the space, and shifted gears to focus on larger companies that required far more complex setups, and generated far more in fees.

It's a shame there has been such a strong movement away from PaaS, it was far easier in the past to get a fully functioning platform up and running than it is today.

Most of my software is written in Haskell, with the Yesod framework handling all the HTTP stuff. Data is mostly persisted in PostgreSQL, with some caching and queueing stuff done in Redis. I try to avoid JavaScript if I can help it. When I do need a richer UI, I'll add small bits of plain JavaScript, sometimes with jQuery. When I need a more complex UI, I use Elm. Everything runs on NixOS machines on AWS.

Not wrestling with constant runtime errors and not being afraid to make broad sweeping changes means I can adapt the software to the business more quickly.

As simple as possible, but not simpler!

I liked Ruby on Rails, but I didn't like the magic, nor did I like the runtime errors.

That's basically how I use Haskell/Yesod. A better Ruby/Rails.

You certainly can do very interesting things with Haskell, but nothing compels you to. Writing boring software in a boring way with Haskell is totally fine, and works well for my businesses.

I'll clarify though that I'm not suggesting I do OOP in Haskell, if anyone reads that into what I wrote.

I don't think relative obscurity makes the technology itself exciting. I certainly didn't choose these technologies to be different, or to be fashionable. If I wanted to play with shiny toys, there are so many others to choose from. The shiny toys don't really appeal to me. I have businesses to run, and the technologies I chose are from a position of total pragmatism.

I sincerely believe it's easier to use Haskell and NixOS for applications of beyond trivial scale than, say, Ruby and Ansible. And I say that from experience.

There's also the Yesod Book which is available to read for free on the same website.

App: React Native with Redux. Flow for types (would use TypeScript if starting again today). RN is a pain but seems better than the alternatives for what I need.

That all allowed me to get a prototype together at the start and to iterate very quickly which was essential for making the whole thing happen at all. Some of that was the technology itself but a lot of it was just that I was very familiar with it.

This was my first project using Elixir/Phoenix and it’s been really fantastic, I couldn’t recommend it enough for being very productive and it’s fairly performant to boot.

The mobile app was built using Flutter (again my first project with Flutter), and it has honestly been great. I come from a Java background and Dart is extremely similar so it took no time at all to get acclimated.

---

Data: Postgres

APIs: Java + Dropwizard

Frontend: Typescript, transitioning from Angular (1.x) to React

Hosting is on a cluster of cheap Linodes, and transactional email is handled by Postmark. Shout out to both of those services, which have been rock-solid compared to others I've tried. I absolutely think the choice of tech has helped Quail succeed -- it's boring software built with boring technology, which leaves me free to focus on the more interesting parts of the business.

Did you evaluate Digital Ocean as an option?

Pardon the website, as there isn't much to see there. We are still in alpha stage. Yes, Clojure ecosystem has been a tremendous help in engineering the system. As a former python dev, I think Clojure made a whole lot of mandatory moving parts unnecessary - like celery and redis for designing such a system. Also, ditching Javascript+react ecosystem with better wrappers has been an absolute blast so far.

Mobile: Xamarin

CI/CD: Azure Devops, AKS

Reason for choosing it: 15+ years of experience with C#, Vue is easy to learn, Xamarin is also C# for both Android and iOS

Amazing that after decades of software development on the web, there is still no "best practice" even though many of these web apps do very similar things. In most other mature industries, best practices tend to settle on just a few approaches. Not so for software development.

The platform is a hosting provider where every site runs off a Lambda function. As such, the hosting costs are miniscule ($0 for almost 2500 sites). The only real fees are the EC2 instances.

Site - https://www.turbo360.co/about

Dedicated AMD 32 core RAID 10 servers from Hetzner running LXD for customer containers — seven containers per server on the cheapest plan. Each dedicated server has their filesystem encrypted with LUKS — including /boot — and each container runs the "default" WordPress stack, i.e., NGINX, PHP-FPM, MariaDB, Redis, ElasticSearch, Postfix, WP-CLI, fail2ban, monit, aide, etc.

WordPress is modified to leak less data by default — heck, by default you can use their REST API to get the email of anyone who leaves a comment —, have a better-looking dashboard experience, and each container runs a TOR bridge to help people in oppressive regimes.

All servers run a slightly modified version of Ubuntu, resolve DNS queries using one of my 8 DNSCrypt servers, are managed using on-premise Canonical Landscape and connect to a Hashicorp Vault instance for credentials and whatnot.

Backups are handled by another big Hetzner server — sitting at 60 TB of storage right now —, by Rsync.net in their Switzerland location and by another server in my house. All backups are encrypted by default, but I still need to implement a way to test them to make sure they work.

The customer portal is being built with Laravel and will connect to the Hashicorp Vault instance to get credentials for customers. We didn't choose the payment gateway yet, as the company is incorporated in Romania and options are kinda scarce, but we will probably go with Adyen and BitPay, which will connect to our Invoice Ninja instance.

The onboarding process for new customers is handled with Jitsi Meet — again, another Hetzner server.

The help desk was initially handled by Help Scout, but I migrated to Full Help recently — which I found on Hacker News —, and I could not be happier. The developer behind it is super awesome and went as far as adding GPG encryption and Postmark support when I asked for it.

I do have six other partners, but as I am currently building everything out myself, I guess it qualifies as a company of one? Partners will be responsible for different parts of the business, i.e., legal, documentation, and whatnot.

>Dedicated AMD 32 core RAID 10 servers from Hetzner running LXD for customer containers — seven containers per server on the cheapest plan. Each dedicated server has their filesystem encrypted with LUKS — including /boot

>All servers run a slightly modified version of Ubuntu, resolve DNS queries using one of my 8 DNSCrypt servers, are managed using on-premise Canonical Landscape and connect to a Hashicorp Vault instance for credentials and whatnot.

>Backups are handled by another big Hetzner server — sitting at 60 TB of storage right now

... I'd love to see what you consider exciting!

Just a side note, do you all have revenue? This seems very overbuilt for a private beta product.

I mean, in the age of Kubernetes and AWS, having your entire stack running on a single server does sound kinda dull to most people. I rather have the performance and simplicity, though.

> Just a side note, do you all have revenue? This seems very overbuilt for a private beta product.

Yes. All customers on the private beta have a 50% discount, but our profit margin is pretty high, to be honest.

The "Medium" plan, which is where all tests are happening, cost us €215,88 per month, which includes the dedicated server, one IP address for each LXD container, about 700 GB of bandwidth from BunnyCDN and emails by Mailgun.

In that plan, we offer 16 GB of ECC memory and 240 GB of NVMe storage. One of our competitors charge $1500 per month for 200 GB of storage, our price is €599.00 per month.

So even with high-profit margins, our cost is below our competition. Which makes you wonder how much profit they make.

But, of course, none of this account for operational costs, employee costs, SaaS costs and things like premium plugins which are offered by default and CDN bandwidth above 700GB — which realistically speaking, will be higher for some customers.

For me, the stopper is WP is thought to be used inside a server with _mutable_ access to everything; whilst k8s needs containers.

This looks good for day-to-day use until you realize your wp needs updating and needs to be done by the operator/editor and somehow propagated back to the system that builds the container.

Usually this is an air gap.

My point was that most people consider my way of doing things "boring", while everything else, i.e., serverless technology, is over hyped.

I have cloudflare setup on top and a custom backup plugin for wordpress.

I am now considering the kubernetes route to split the editing and frontend workflows.

My customers are engineers (of the traditional type) and Windows is very popular among them. I chose VB.net because it solved some problems I was having with VB6, which I chose because I inherited it from my predecessor who used it when it was the fashionable thing.

Effects:- This tech is mature now and comes with steroids in its own, hence we never faced major difficulties wrt to tech stack and that's always a good place to be in. (Good read on the same topic:- https://www.intercom.com/blog/run-less-software/)

And we're hiring http://www.squadvoice.co/careers-us/

It's a minimal stack with intentionally dead-simple architecture. Its the lowest common denominator in Boring Technology.

Someday when we scale beyond One Developer I don't want to be trying to hire the best Blockchain Rust DevOps Cloud Engineer Stanford CS produced last year ... I want to hire a contractor who knows SQL, HTML and has seen Javascript and Java.

Always good to underbuild then adopt complications as needed.

Stack is: NixOS, because, despite the learning curve and all the quirks, at the end I love having all the infrastructure configs in one folder (so I never forget that I have an obscure cron job somewhere).

Clojure/ClojureScript, because I am good at Clojure (this is what I do on freelancing side)

For simple services that's always a Datomic on MariaDB (with a replication server) and a backend. Servers run on Hetzner ($2-$5 instances are fine, with replication I need two) Backups on S3.

- PostgreSQL + Sqlite. I try to use both for everything: Log analysis, reports, dashboards, etc + obvious crud stuff. - Python3 for scripting - If have not choice: HTML, JS + Vue - Simple vultr/digital ocean vps

Rust allow me to get rid of docker (just deploy a binary! Like in my Delphi days!) and other complex stuff. I'm near "copy-paste" deployment now.

My only fancy tech now is using azure pipelines for compile across platforms (like android + ios).

My frontend is vue.js

My backend is in a home made c++ framework. I'm rewriting it to achieve even higher performance and concurrency. I think my choice of c++ helps me save server resources, and it can be deployed easily. (just scp a folder of a few binaries)

my database is mongodb for now. However, I want to switch to postgresql.

So i guess sticking with what you already know is the best when starting out.

Finding product/market fit is waaaay more difficult than learning new tech.

You will have time to optimize it later when you get traction and the product kept together by duct tape starts to fall apart under pressure.

Backend - Lambda / TypeScript

Infrastructure - AWS CDK / TypeScript

Kept in a monorepo, which means tightly-coupled code-sharing between all the different components.

Definitely has it's negatives - but being in small startup (solo technical) also means lots of interruptions and chopping and changing.

Having one language, stack, and repo makes it much easier to me to start, stop, and pick things up as I go.

It's funny how one persons dream is another person's nightmare.

Tightly coupled software is horrifying to me. Modularization all the way; define contracts then build away.

In this case, the contract is shared TypeScript types between the front and back-ends. This means you can statically verify as much as the type system allows.

Did you have a solid AWS experience prior?

A lot of cloudformation quirks leak directly into CDK. And I've learned to be patient (e.g. one change at a time, roll though all environments, do adds and deletes separately...).

Right now using it is 50/50 for me. I'm assuming as more construct libraries become commonplace that will help the most (up until recently this was hamstrung by the amount of breaking changes)

The stack mostly just works - in that regard it’s much easier being a developer now. The really pleasant surprise was how little code I needed for the numeric stuff (basic ML with PCA).

https://www.agendashift.com

In development, all services can be brought up using Docker Compose within a monorepo.

Frontend: Ember.js Backend: Ruby on Rails, nginx, Postgres, Redis, Sidekiq, VueJS (marketing site) Metrics: Prometheus, Grafana, Papertrail Infrastructure: Ubuntu, Docker Swarm CI/CD: Google Cloud Build

I also run a few ad-hoc scripts in Google Cloud Run that perform very specific duties like triggering CI/CD builds or sending Slack notifications.

Google Cloud Platform is great!

[1] https://trunkinventory.com

The stack is simple and easy to work with, locally and in prod.

Effect on success: knew the tech well so did not have to spend time learning the tech in addition to all the business learning.

Making a business is very involved. If you can simplify the technology side it’s a good idea.

--

Backend: Node.js hosted on AWS ECS (Docker) and Lambda Frontend: JavaScript, React Database: Postgres (AWS RDS; thinking about switching to serverless aurora)

As for delivering my clients sites I recently switched from cloudfront to stackpath (DNS, CDN) because the pricing model makes more sense for me and it doesn't have arbitrary limitations like the distribution limit.

Other tech I use:

- Terraform for my whole infrastructure

- AWS SES for sending mails

- AWS Cognito for authentication and managing user accounts

- AWS Cloudfront combined with lambda@edge for delivering images in the right size for the requester (src-set)

- Github

- AWS CodePipeline for CI and deployments (source input through github releases)

I'm using a combination of Node.js, Golang, React+Redux, Express.js, MongoDB, Redis, Docker, AWS Fargate, Heroku, DigitalOcean, Netlify, AWS SNS, AWS SES, Stripe and Github.

I managed to go from idea to product in 3 weekends. I could have built the same thing with any programming language and hosting provider, but not with the same speed. The result is that I am able to iterate and build much faster by using a tech stack that I am very familiar with.

[1] https://codertest.io

Elastic Beanstalk with ELB and EC2 autoscaling running Node.js backend

React for SPA

Cognito for user management/auth

Github for source control

CodePipeline for CI and deployments

Cloudfront with lambda@edge for SPA

Cloudinary for media hosting

RDS for database

LogRocket for frontend error capturing

Sentry for backend error capturing

Lambda to write a new user to RDS after confirmation trigger from cognito.

In my case, since I'm teaching this stack (at https://alchemist.camp), it was a great choice. I think there's a bit more credibility in using what I'm teaching instead of just using an off-the-shelf solution, and it's also been a source of inspiration for some of the content, too.

Being able to handle more visitors and traffic than I'll ever likely get on a total infrastructure cost of just over $7/month, is great, too.

It's Clojure in the back end, on Postegres, on Heroku. Everything in the product front-end is ClojureScript, with reagent, hosted in S3 behind CloudFront.

All deployments through CircleCI, GitHub for VCS. Emacs for development, on a Dell XPS 13 with Ubuntu :)

Marketing website is a static site, built with Middleman; again, CloudFront + S3.

1. https://trolley.link

Debian, KVM, Apache, MySQL (with Percona for clustering), GlusterFS, rSync, HAProxy, PHP, jQuery

I actually own 3 servers :) I know, it's super boring, but this stack has only failed me once in about five years.

Yes, in my opinion this stack has helped me a lot in earning a living with my company because it just works and saves me time to do other things that earn money.

Think it like, I am an Indian and want this software in Hindi/Gujarati/Tamil. What I will do is grab your global English file, Translate the appropriate part of strings to my choice of language and push those changes to your software. which means user who are capable will support ecosystem.

Backend: Scala and Playframework

Frontend: Jquery

DB: RDS, Postgresql on AWS

Hosting: Baremetal on Scaleway

DNS: AWS Route53

Object Store: AWS S3

CDN: AWS CloudFront

Infrastructure: Ansible and Kubernetes

Monitoring: CloudWatch and Influxdb + Grafana in k8s

Logging: ELK in k8s

Scaleway is a great hosting with cheap price. Instead of finding reliable but expensive hosting, I prefer cheaper hosting, but more servers and build HA to handle server issue. Server die all the time.

Advantage: You can run a lot of stuff with a free tier setup, minimising the amount of investment in the beginning.

I use this setup to run https://www.surfgreen.dev

and to develop energy efficient, sustainable and green websites and webapps.

Go server rendered pages + vanilla Javascript, with Postgres + Redis. Simple cicd using github + gocd and docker swarm. The simple setup and no framework allows for minimal page load times, and no browser impact.

I wouldn't worry too much about the stack of the day. Crack on and make something you can call your own.

I use pretty much anything that gets the job done with the least dev time.

It's likely been helpful because it's a stack I'm good with, and it has very mature tooling and libraries (via JVM). The alternative was basically C, which has higher quality mailserver libraries but seemed a lot harder to work with from my point of view.

Actual product though i'm building in ReactJS / will have PHP / PostgreSQL backend.

Web framework: Ruby on Rails

UI JS/CSS Framework: Bootstrap, Bulma

DB: PostgreSQL

Hosting: Vultr, Digital Ocean, Heroku

External Products: Amazon SES, Sendgrid

Frontend: Angular 7, Angular Material 7, Apollo GraphQL

SaaS (free tiers): Auth0, Sentry.io, Smallchat, Braintree, Netlify

Hosting: Hetzner

db: postgres

hosting: centos on linode servers

external services: mailgun, geoipservice, paypal, paddle

Other tech I use

- Serverless framework on AWS Lambda

- Postgres

- Sidekiq

- Dokku

- Sentry

- New Relic

- gRPC and Twirp [2]

- Netlify

- Firebase

[1] https://www.searchbx.com

[2] https://github.com/twitchtv/twirp

Development goes really fast forMVP (for eg https://dokomaps.com)

This gets the job done with minimal friction and ease of use.

Stack: C#, .NET Core, WebAPI, Javascript, ReactJS, TypeScript, SQL Server, MongoDB, Windows /IIS, Jenkins, GIT, AWS.

React + bulma. Java 12/latest with homemade minimal stack. MySQL database. Digital ocean box running a tomcat servlet container.

I know it well and it is very fast to work with (fast edit / test / deploy cycle).

Web: stbl + nginx on a linode.

Data Infrastructure: Nextcloud containerized on a linode.

Server: Digital Ocean / AWS

SaaS: Airtable, Helpscout, Sendinblue, Sendgrid, balsamiq, StatusCake, Typeform

Making libraries and apps for Apple stuff. Mostly open-source, but I have some closed-source stuff on the stove, as well.

It seems to make me a bit of an outlier, but I enjoy the work.

Success? More will be revealed...

Front end: ReactJS, Firebase Back end: PHP, SQL

100% infrastructure as code using serverless framework and cloudformation. architecture scales well, is fully managed, and super cheap to run. almost no cost if no users. express + next js + lambda pretenders the ui for speed and seo.

Backend: Go / Postgres / Elasticsearch

Infrastructure: Google Cloud / GKE

Mobile: Xamarin

CI/CD: GitlabCI(Linux), GithubActions(macOS+Windows)

Soon: Rust

Database upgrades are stores in an upgrades/<version>/upgrade.sql format. There can also be upgrades/<version>/upgrade.sh shell scripts.

For testing: back end is a bunch of single files run through a small, purpose built wrapper. Front end uses Jest.

Git hooks run locally for pre-commit and releases. Deployment is handled automatically by GitHub web hooks. The server handles any upgrade file (upgrade.sql and / or upgrade.sh) as triggered by GitHub web hooks. General rule of thumb here is never commit or push to master unless you're confident everything is ready (this only really works for a single person!)

Application server runs on a single instance Debian VM on Azure. MySQL runs on a separate VM instance on Azure, with a failover configured. There's also a read-only MySQL replica which is used for pulling large amounts of reporting data.

For backup (outside of that provided by Azure), there's a series of shell scripts running on cron to dump the database to an encrypted and time stamped backup. These are periodically fetched by other servers in different locations. Backups are kept for every business hour of operation. For user generated files (>1TB per year), rsync is run every hour on a couple of backup machines. Backups are manually checked by a person (for completeness and restorability) once per month. Automated backup checks are run daily on cron.

The longest down time that has been had in six years is fifteen minutes which was due to a bad database upgrade.