Ask HN: Companies of one, what is your tech stack?

I run https://rpgplayground.com, a web tool to make RPG games without coding (6000+ user published games) The app itself is written in Haxe. My website is WordPress.

Haxe because it will be easy to port to any device.

Why was WordPress the best choice? Basically everything you need has a plugin.

I needed a forum: bbPress

I needed a community where my members post updates: BuddyPress

I need to send out a newsletter, and most Saas options are crazy expensive: plugin mailster.co, 1 time payment. (Using critsend.com)

Needed some faq page with search, needed a captcha for registering, experimented with ads, post updates to discord, user reporting system, ... You name it, there is a plugin for that.

I also have an external person who writes my newsletters, but isn't allowed push the "publish" button. All thanks to the user roles functionality.

Of course I needed my own plugin to integrate my app and show shared games. I could have written that myself, but then I would lose out on time developing my tool. So I was able to hire a cheap php WordPress developer who made my custom plugin. Went great!

WordPress is so crazy powerfull, that if you want to create some community website, it offers everything you need.

I know my experience is not what many of you would expect, so therefore thought it was interesting to share it with you.

Stack: Postgresql+Rails+Hotwire.

I really dig Stimulus and Turbo Frames. It took me a little while to really wrap my head around Turbo Streams. I think the documentation is pretty bad compared to the rest of the Hotwire stack, but—holy moly—once I had it working, it's really like a superpower for front-end development. Using Turbo Streams reminds me a bit of the sort of 'head exploding' moments I had first working with Rails back in 2007 or so. https://www.hotwired.dev

UI: I use Tailwind and Tailwind UI, and aggressively componentize the UI with ViewComponent to make it easier and more manageable to build reusable components and to keep from shooting myself in the foot. Tailwind would be frustrating to use if you crafted bespoke UI elements on every page, but it's an absolute godsend if you're componentizing all of your UI. (Also, if you're not componentizing your UI, why are you wasting so much of your time?) https://www.tailwindcss.com

APM: I use https://skylight.io for performance monitoring, and https://sentry.io for exception tracking.

It runs on Craft CMS inside Docker on DigitalOcean. I chose Craft because it lets you create custom post types with custom fields really easily. The matrix fields let you have rich text mixed with other widgets. All of this was a pain in WordPress.

On the other hand, using not-WordPress means that you're on your own. You can't hammer a bunch of plugins together and call it a day.

The theme is entirely custom-made. It's not exactly groundbreaking, but I've spent a lot of time optimising for page speed and content readability. It's heavily inspired by the NHS' website.

I use nginx to bind everything together and cache responses. I wasted way too much time getting cache purging and automatic SSL certs to work. It has no business being that complicated. I regret taking 5 years to look at Cloudflare.

The tools and calculators (https://allaboutberlin.com/tools/) are built with Vue, with vanilla JS business logic libraries.

These services are practically stackless: there’s a Node app with Express as the only dependency. No database, persistence to local files, entire data model cached in memory as JavaScript objects. When the service restarts, it rebuilds the memory image from the file system. The data formats are a mix of mostly append-only logs (JSON lines) and some plain JSON for objects where it doesn’t make sense to keep the full change history. Backups and restore to another server are super easy when there’s a bunch of files and a single Node script to launch.

Lately I’ve been building a hobby product where the front-end is stackless too. Plain HTML and modern JavaScript, using ES modules in the browser. No build chain at all. I don’t need to support IE so all modern language features are natively available, and the app is small enough that a bundler doesn’t deliver huge benefits. This means I don’t have access to npm, but so far it’s been fine because browsers do so much these days and the APIs have improved tremendously in the past decade.

I’ll probably stick with stackless for anything I maintain alone and doesn’t have huge growth expectations. But I wouldn’t expect to convince anyone else in a professional environment, so in the real world there’s no escaping from half-gig node_modules and complex Docker builds and all that dance.

The apps were made long before Docker was a thing, so they just run as regular ol' processes, locked down as much as possible with systemd magic. I originally used uwsgi as my wsgi server, but it turns out gunicorn is vastly more efficient so I use it exclusively now.

I run a warm standby server at Hetzner so I can route traffic there in a pinch. I have a second warm standby running at my house because I'm truly paranoid about automated account bans (despite the very innocuous nature of my business). Backups are at rsync.net.

My single point of failure is DNS. I had a good relationship with DNSMadeEasy so I was not too worried about automated bans. But they were just bought by DigiCert, so that's a problem now.

Payments are handled with Stripe and PayPal. I added PayPal (despite my hatred of the company) just because I'm scared Stripe will ban me without warning, for no reason, and won't communicate with me.

For user uploads, I have an aiohttp Python server that streams files to Wasabi and Backblaze, and caches them in nginx at the same time. So my cloud bandwidth bill is usually 0.

The websocket layer is kind of wonky. Originally, I used the Python websockets asyncio library to do everything. It worked for a while, and then I had to make it multi-process to spread the load. But it was just eating resources like crazy. I decided to use OpenResty's websocket stuff to handle the connections, but I didn't want to write all the complex application logic in Lua. So I used Redis pub/sub to pass messages back and forth from OpenResty-land to a pool of (sync) Python processes. It worked much better. That said, I'm a novice with asyncio, so I could very easily be to blame for the original performance problems.

And sorry, I won't tell you the name of my apps (I don't need any more competitors!)

- Rails: so I have a UI quickly together with some admin and a interactive shell to allow me interact with the app easiser - GoodJobs:https://github.com/bensheldon/good_job Used this for any Rails based job - Postgres for everything. No Redis. I found redis is a source of pain when it misbehave and reach max mem with eviction policy. When Redis mem is big, restart it take quite a bit of time. - Huge server: I rent hetzner server and scale vertically. - Golang + sqlc: I used Rails SQL schema to pair it with golang sqlc https://sqlc.dev/ it makes write SQL way easier - Stimulus - Docker Compose for Rails deployment - SCP/Systemd for go-based servic

https://mailwip.com is my email forwarding saas app.

Hosted on Heroku, using Sentry for error tracking, New Relic for performance monitoring, Sendgrid for email. Recently ditched Google Analytics in favor of Plausible for general analytics and Ahoy (Rails middleware) for deeper in-house analytics. Using Intercom for support/chat widget, but planning to switch to Chatwoot. Considering moving off Heroku, but the most obvious contender, Render, doesn't yet have high availability postgres with automatic failover.

Deployment is set up so any push to the master branch on GitHub is automatically deployed to production. Merging to the master branch can only be done via a PR, and needs green status from both linter (Rubocop), tests (Rspec run on CircleCI, both unit and integration) and coverage (100% test coverage required, verified by codecov.io).

UI is Bootstrap (but feeling long in the tooth), and server side rendering with a sprinkling of javascript. Still mulling over hotwire/turbo vs alpine vs stimulus vs react for some upcoming UI that requires more interactivity.

Backend: Rust, rocket, sqlx, postgres + a little bit of R. Ansible for deployment.

Frontend: Rescript + React. Also a significant portion of Rust/WASM, but that was a mistake I'm trying to undo.

In short, statically typed and functional(-ish).

- Web backend in go using html templates and some js

- Frontend in plain js and scss

- go server for cron jobs

- postgres for store

- redis for queueing

- ngingx for load balancing and ssl termination

- certbot for ssl

Each of those services is a docker image, all of those images are tied together in a docker compose file. One for dev, one for prod.

Terraform for object store, server, and volume infrastructure.

Bash scripts for deployment using ssh.

Server-side: Node.js, Fastify, Prisma, Handlebars (email templating)

Front-end: Next.js, Chakra UI, React Query, Comlink (web workers), Dexie (IndexedDB), Recharts, Formik.

Tooling: TypeScript, ESBuild, Jest, Playwright

Backing services: PostgreSQL, Redis, MailPace (transactional emails)

Deployment/Ops: GitHub Actions, Clever Cloud hosting

Backend: Building a REST/GraphQL API that could be deployed to Cloudflare workers is a no brainer. Super cheap and incredibly fast and when you need to scale it’s still ridiculously cheap. I’d probaby go with REST with swagger + openapi-typescript to generate types on the frontend because honestly GraphQL is a lot of work for one person to maintain.

Frontend: Next.js server render or ISG hosted on Vercel. I'd throw Tailwind on too for rapidly styling your pages.

Database: Prisma with Postgres so it could be typed and works well with other tools. I still haven’t figured where to host Postgres easily. Looking for something like Mongo Atlas where I could grab the connection URL easily and has affordable free/paid plans.

FE - Vue2, Nuxt, Tailwind

Native - Capacitor 100% code sharing with web FE. Fastlane to automate build/signing/submissions

Cloudflare workers acting as a proxy for both FE cache and BE API rate limiting/maintenance mode read from KV store.

I made a crude diagram: https://t20654125.p.clickup-attachments.com/t20654125/133842...

- Linode Ubuntu - Vue - Laravel PHP - PostgreSQL - Tailwind

That's it. Keeps me focused.

Backend: Python / SqlAlchemy

DB: Postgres

Cache: Redis

Frontend: React / Redux / Emotion / Socket.io

Reverse Proxy: Traefik

Marketing Site: Next.js

CDN/File hosting: Cloudflare, R2

Backups: Tarsnap

Deployment: Docker / Docker Compose

Server configuration: Ansible

Mobile: React Native

Payments: Stripe

Email (Transactional/Marketing): Postmark

If I were to start today, I would probably start with something else. But this stack has served me well for years, and still going strong with 36 apps and counting. I'm constantly evolving it as the tech progresses.

* PostgreSQL database.

* Go for an API.

* Python + Django for a UI.

* Linode hosting, very few larger boxes rather than lots of small boxes.

These are not my business, I want to pay someone to do these or I want such simplicity that it's a non-issue:

* Grafana Cloud for monitoring and alerts (nearly all Prometheus based, but some log based alerts and log based dashboards).

* A few Excel spreadsheets, which I keep as Excel to enable easier sharing with accountant. Besides, he's probably sharing Word docs back to me.

* Syncthing + a NAS for file storage of the business files and accounts.

* I do all payments via PayPal. I wanted to use Stripe but people really want to pay with PayPal so I centralised there.

* I use Xero to track accounts, assets, etc.

I pay about USD 1k per month in various hosting costs, then the Xero subscription, and an annual subscription for MS Office which I consider part of the accounting costs. I use a local small business accountant who only charges GBP 250 for annual accounts.

Uptime monitoring:

- fly.io w/ redundancy on AWS

- Redis

- Node.js

- Postgres

Uptime monitoring frontend:

- Next.js

- Tailwind CSS

Status Pages:

- Remix (React) frontend, heavily cached on Cloudflare Workers

I try to avoid trends and only run on simple, straightforward but most of all proven and stable tech.

The core software is a mix of C++ and C#. Mostly moving toward C# for new features.

I use JetBrains TeamCity for continuous integration and testing. Where test scripts are mostly VBScript or Powershell. Using plain old self-hosted SVN for versioning.

Backoffice; like sales and licensing servers are all ASP classic.

The website is a custom WordPress template running at a shared hosting company.

Also, I strongly believe in 'dogfooding' as in 'Eat your own dogfood'. I use my own software products wherever I can. That really helps me find weaknesses and improve on usability.

For me it's worth a lot if new functionality, once built, can be left alone an add value for as long as possible.

"Use boring technology" - Laravel, MySQL, Fly.io for hosting

We automate nearly all aspects of the business as well. If a task needs to be done more than once, it's worth automating. GitHub actions to test/deploy, admin pages for all activities such as marketplace submissions, payouts, tax reports, chargebacks/refunds ... If there is ever a problem with a purchase, we have ways to reply and refund all with the click of a button.

We recently switched from a VPS to Fly.io and PlanetScale as well and it's been working quite nicely. As we grow to more regions, it's nice to know we can deploy servers close to our users with a single command.

[1]: https://news.ycombinator.com/item?id=20985875

[2]: https://www.listennotes.com/blog/the-boring-technology-behin...

[3]: https://www.listennotes.com/blog/good-enough-engineering-to-...

The main app that my users run is written in TypeScript and runs with Node/Express/Vue/Knex/SQLite. Third party dependencies are only pulled in after a code review and are scanned with snyk and npm/yarn audit. You can see the current list of deps here: https://github.com/photostructure/photostructure-for-servers.... ExifTool (excellent metadata extraction) and Sharp (fast image processing via LibVips) deserve all the kudos I can muster.

Additionally, there are three droplets/virtual hosts that I run:

https://photostructure.com/ is a static Hugo site, served by nginx.

https://forum.photostructure.com/ is served by Discourse, which is a rails app.

The account subscription management website is written in TypeScript using Node/Express/Knex/PostgreSQL, clustered by pm2, and reverse proxied for https by Caddy. Billing is currently handled via Stripe Checkout.

At home, I have 10+ computers that help me with customer support as well as host GitHub Actions to run continuous integration tests on all supported platforms.

AMA!

Main Website: wordpress, WooCommerce, stripe

Mobile Apps (iOS/Android): Flutter, Firebase

WebApp: ReactJS, Firebase

Hardware Firmware: C

- PostgreSQL + Sqlite (PG is not that uncommon anymore!) as the main stores. I refuse to add anything else as far as I can, ie: Any other NoSQL thing, so I try to go with in-built functionality like FTS, Json, etc. Decent RDBMS usage is super-efficient and scale well for most workloads

- Rust as main lang. Speed is nice, but having a language that reduce bugs and maintenance cost is BIG plus. In the long run, is better ($$$$$) to have a little of "slow development" to offset "so much bug hunting!". Go "fast, break things" is only viable for very rich, very big companies that are after very fast growth. Most of us, take slow and methodical is much better, IMHO.

- htmx + tailwindcss for front-end, hands-on the BEST combo in my +20 years doing web stuff.

- Simple http://vultr.com hosting with cloudflare on front. Thanks to Rust/PG I even have very small ones too.

- nginx + nixos + circleci as the operative backbone. NixOS replace all my custom docker/scripts/ansible-like setup in a single thing.

The only thing I hate to do that have only cause problems, all the time, is Android. I wish I could do only iOS, so much easier and sane for solo dev.

The majority of the video processing and indexing work is done offline. I have a CLI tool that creates the data files for Hugo on my local box. Because of this, I don't need a database. I just run the tool, git push, and the data on the site automatically updates. The frontend is vanilla HTML, JS, and CSS.

I use PHP and bash for all of my automation, and python for the UIs.

It uses a Django+sqlite backend, on a single AWS tiny instance. Frontend is mostly "VanillaJS". Traffic is relatively modest at a couple thousand hits per day. Been using this setup for 8+ years now. Wouldn't have chosen anything else, even in retrospect.

Stack is Go + SQLite + nginx + htmx.

I am now working on a simple orchestrator in Go that manages hundreds to thousands of these small silos across multiple servers giving people proper isolated SaaS type environments which can be entirely downloaded and run locally if desired as only two files (program + database)!

Frameworks/platforms: Django/DRF, Node, VueJS. DB: PostgreSQL, running on DigitalOcean (vps), server provisioning and deployments using Ansible.

For https://musicbox.com.hr (music streaming service for bars, restaurants, shops, etc):

Django/DRF with PostgreSQL for the API, VueJS for the frontend apps, Go for the streaming service, Redis, Go on RaspberryPi for specialized hw players. Hosting on Hetzner and DigitalOcean (vps + managed dbs), using Tailscale to have everything in a single VPN. Deployment with Ansible.

I find Ansible to be a hidden gem here. Nowadays its mostly overlooked for fancy k8s setups, but especially for small number of servers (a few), there's a lot less moving parts to worry about (and they're all explicit in the single yaml file).

File sync via SyncThing.

Rendering to ePub, txt, PDF, HTML and DocBook via a combination of TeX, texinfo and shell.

And... That's it. Everything web hasn't been touched in about three years. Just static, apart from payment JS.

- Extremely simple setup orchestrated with docker compose

- Primary / perf sensitive areas implemented in Rust; some internal APIs and web facing stuff implemented in Go - there's basically the colour profile page implemented in Rust, a "core" Rust library for shared functionality and two API servers, one in Rust, one in Go

- Some data juggling done in Python (nothing fancy, basically all hand-rolled)

- Postgres database; this is treated as immutable; there's processes for adding data that's rather manual due to it requiring to be curated - a Postgres dump artefact is added to git lfs

- Exposed via Nginx, also using Cloudflare LB

- HTML templating a mixture of hand-rolled and Go templates

- Sass for style sheets

- Vanilla Typescript for the frontend

- Hosted on VPS with the best price/perf ratio (currently UpCloud)

Django, Celery, Postgres, RabbitMQ, Minio, Lots of different Python environments for different scientific “stacks” (some pip based, some conda)

Machine learning done in pytorch, models wrapped and deployed by simple FastAPI wrappers

Deployment moving to be totally dockerized (maybe 90% done) because I was having a lot of trouble with deploying esoteric, fragile, scientific libs.

System core is a monolith, with a bunch of micro services in different repos - especially worker machines (structure optimisers, various energy calculators, etc) this way worker code can be deployed to relatively untrusted machines without having to put the entire codebase on there.

I applied for ycombinator this batch, I am hoping to get in, and find a cofounder at the same time

It was my first time using the Stripe API too, which has the nicest documentation I've ever seen!

I've recently started remaking parts of it in a static site generator I've written focussed on Jupyter notebooks. The first part I've replaced is the Docs (https://PlotAPI.com/docs) - it's a WIP!

Monster server (128GB RAM, 18 core) on Hetzner ($60/mo). CloudFlare to front everything to add a little extra security mostly - I only allow my home IP and CF to connect directly to the app/db/web server.

* MySQL, because one key source has a library that ingests easily to MySQL

* Postgres for the main warehouse and app data (fdw to pull in MySQL data)

* Django for the webapp, with celery and redis for async jobs

* SES for email

* Prefect (vs Airflow) for running data ingestion/transform jobs

* DBT (triggered by prefect) for transform jobs

* Netlify for the static site frontend, jekyll for static site gen

* Google Analytics

Google cloud platform utilising Postgres Cloud SQL, Cloud Run and Tasks. Email through AWS SES and blob storage on S3.

Server: Node.js, GraphQL, TypeGraphql, Apollo Server, PostgresQL 14, Redis

Website: Webflow (great for a good website with minimal work)

Hosting: Digital Ocean (it’s cheap but I prefer GCP)

Internal tools: Retool

AWS, PostgreSQL + Redis + S3, BE is 100% Python-based Lambda functions, FE is browser-native WebComponents (no frameworks), mobile app is the same FE code wrapped with Cordova, on Google Play and Apple App Store.

Serverless functions are my #1 tip to reduce low-value maintenance time for solo devs / small teams.

For desktop I mainly use C# on Windows but would love to dedicate more time to Smalltalk, a very cool concept and language.

https://tamagui.dev/docs/intro/compiler

I use:

- Tamagui + React + React Native

- Hasura + Postgres + GQty[1]

- A long-fought after monorepo with a bunch of stuff to make this all dev nicely and deploy with a push (for now Docker Swarm + Hetzner. GCloud + Kubes was too heavy, tried Fly a while ago and it was a bit too green).

[1] https://gqty.dev

Backend: Orleans + .NET Minimal API's hosted in Azure Container Apps

Real-time PubSub: SignalR

Deployment: GitHub Actions

The reason for this was because PHP developers are cheaper. So if project takes off, it will be cheaper to hire PHP devs.

JavaScript is better as an employee since JS/Node/React devs are more in demand and pays better.

marketing site: hugo, netlify

tools: cloudflare, namecheap, mailjet, stripe, twilio, sentry, papertrail, slack

And I self-host with a little bit of Bash on single VM as I described in Deployment from Scratch.

The minimalism might not stay forever, but before you hit any real success, you should keep things plain, boring, and maintainable.

Web backend: Django

DNS/Web API backends: Go, Flask, Tornado

DB: Postgres, SQLite

Cache: Redis

Frontend: htmx (via jQuery, Backbone.js and Vue.js)

Marketing site: Cloudflare Pages

Hosting: Mix of Heroku, Linode and Fly

Backups: Backupsy

Dev: Linux and Docker Compose

Payments: Stripe and PayPal (reluctantly)

I wrote about parts of it here: https://wakatime.com/blog/category/engineering

1) to target both iOS and Android devices

2) to be real-time for social networking and collaborative tasks

3) available in both offline and online modes

4) to have no cost of developing and testing with small audience.

Turned out I could achieve all of the above using Flutter + Firebase (Auth & Firestore).

Desktop app: Electron + Angular + Express + Firebase Remote Config CLI: Node.js app using Oclif and Express In a basic monorepo using Lerna

Website: Next.js Website's hosting: Firebase hosting + CloudFlare

CI: GitHub Actions

Project management: GitHub Projects

Support: Email, Discord, GitHub Discussions

Project is https://mockoon.com

It's optimized for building a decent looking startup website in half an hour.

We now have an in house designer and frontend team so the whole thing will be replaced soon... But it got us fairly far.

Elixir/Phoenix/Liveview/Postgres with alpine.js and tailwind for the dashboard overview for the operations analytics (hosted on fly.io)

All code and pipelines on GitHub

Currently building as well flutter apps but it’s taking a lot of time in comparison with the webapp and operations dashboard

E-commerce is Noopcommerce.

New stack is the SAFE stack with postgress as the db. Flyway for database migration. Docker deployments with a gitlab CI pipeline.

Soon to add Apache Kafka for message flow.

Initial development with this stack is not especially fast but bug fixes and changes are so easy.

Linux, AWS, MySQL, Perl

HTML still works it turns out!

That's it. Very easy.

Here is a sample: https://teusonho.org - analyze your dreams in Portuguese.

- Golang, Redis, TimescaleDB - an absolute game changer for time-series data

- Fargate, SQS, Lambdas in AWS

- Docker and GitHub Actions

One app is a multi-user game that 60K+ users play regularly Other is a productivity app available on multiple platforms

Backend: Cloudflare Durable Objects for the consumer-facing app, Python cronjobs on a GCP hosted VM for background task processing, FastAPI for self-hosted vector search

Frontend: Nextjs. Antd as UI framework, Highcharts for charts. Hosted on Vercel

website+e-commence: shopify liquid, later moved to typescript+hydrogen

embedded Android: Kotlin

mobile app: Flutter

Backend: go + postgres on heroku, with some lambdas for periodical work.

The thing surprised me most is the amount of downtime Github and heroku had in past year.

Quite a pleasant experience overall for what I need.

Frontend: React/Typescript

Backend: React/Typescript, Nim

DB: Postgres

Hosting: Namecheap, Cloudflare, ZAP-Hosting

Docker + Alpine Nginx AWS: ECS, REDIS, RDS/PG Backend: Django / DRF Front End: Next / React IaC: Pulumi

Infra: AWS and serverless application model (SAM)

Frontend app: react

Backend: python + lambda, step functions, dynamodb, and sagemaker.

CI/CD: GitHub actions

Super stable, multi-region, low maintenance and near infinitely scalable.

Web Server: Nginx

Container: LXD or Docker

Backup: FreeBSD with zfs

Server-side: PHP and Python

CMS/Web framework: WordPress, MediaWiki and Django

Database: Postgresql and MySQL/MariaDB

Cloud: Linode and AWS

Currently learning: Dart and Flutter to build a cross-platform app for my next idea.

Hosted on Linode

Boring but hella productive and stable, and lots of stability and depth in the ecosystem.

Great stack for the solo dev imo.

We use Java, Spring, MySQL, Redis, and a couple dozen colocated servers. Ansible is used to manage the servers.

React + Typescript frontend

Rust backend

Architecture stuff: kubernetes, Kong, postgres, all hosted on DO

Backend

- Auth: stytch

- DB: Postgres in RDS (moving to Railway)

- Api: Node on Heroku (moving to Railway)

- Images: Fire Store (ugh. Maybe move to Cloudflare images)

Front end

- SPA: React served by Heroku (moving to Railway)

I love the stack, but I was already really experienced with these tools which helped.

Backend: spring boot, kotlin

Frontend: reactjs, nextjs, typescript

Web stack: nextjs, symfony or fastapi, netlify

Monitoring: Matomo, metabase, signoz, prometheus.

on top: TypeScript, Node, Express, React, Postgres Other: Webpack, yarn, scss

other: Heroku, GitHub

- Nginx webserver

- asp.net / dotnet / c#

- vanilla js

AWS EC2 Debian Linux

Let's Encrypt

The product is built with some open source and some retrained models, it analyses input links or linked images with tesseract/unified IO / OFA / beautiful soup so it can answer questions about images/receipts etc.

The site itself is on app engine standard python with stripe/firebase UI for auth, which is running very cost effectively.

In future in planning to layer on more content understanding eg audio with whisper etc, then milvus/haystack for lookup phases for more factual question answering, then some work on automated retraining and regeneration etc for hard cases, then searching other systems/internal code and logic execution etc, eventually with a few more steps I'm hoping it will feel like I made AGI in a rack in my house lol...