Companies of one, what is your tech stack?

You're going to love to hate this: Best choice I made was using WordPress!

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.

I run https://text-generator.io competing with OpenAI. I used to use kubernetes on Google cloud, but now run it from my house behind a CloudFlare tunnel believe it or not Using my own GPUs allows me to undercut them with around 10x cheaper pricing.

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...

Hosting on Render.

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.

I run https://allaboutberlin.com

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.

I have some stuff running with minimal maintenance, never any surprises, just chugging along year after year.

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.

I run several SaaS apps on a single big OVH server. It handles 6 million non-cached requests per day. The backend stack is pretty basic: Django/Python, MySQL, redis (pub/sub) for websockets. But the secret sauce is OpenResty. I use Lua scripts to do more sophisticated page caching (because the builtin nginx caching is so primitive), DDoS protection, handling websockets, offloading long running requests, and routing between my unix socket upsteams. It's a poor man's Cloudflare in 1500 lines of Lua.

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!)

I used a weird stack of:

- 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.

Rails (6.1), Postgres, Redis, Sidekiq

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.

Building an agtech platform (with quite a few other people, including a designer and data scientist, but I'm currently the sole developer, and for the most part it was built by a single developer).

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).

Services:

- 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.

If you want an ultra productive, easy to learn and a delight to deploy+maintain stack, consider PETAL: Phoenix, Elixir, Tailwind, Alpine.js & LiveView. See: https://github.com/dwyl/technology-stack

TypeScript monolith based on the following:

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

Not a company but I’ve been experimenting with different tech stack options over the last 6 months to find a simple tech stack with an independent frontend and an independent backend with a hosted database. The goal is not just to build but also be able to maintain without much complexity and not spend a lot of money on 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.

BE - Lambda function URLs, Node, Fastify, Knex with Objection.js, RDS Proxy Postgres

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...

I try to keep things very simple + boring for Newsy (https://newsy.co)

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

That's it. Keeps me focused.

Hosting: Bare metal on Hetzner.

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.

These are my business, I run these:

* 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.

I run an uptime monitoring + status page service: https://onlineornot.com

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

We're building enterprise software that runs mostly on-premise as well as we're offering some libraries for sending SMS and E-mail.

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.

I'm wondering how you all ensure business continuity. To not highjack this discussion I posted a new Ask HN at https://news.ycombinator.com/item?id=32960255, I hope you can share your experience there

https://dddice.com - 3D dice roller

"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.

There once were discussions on HN, e.g. [1] about listennotes blog posts[2][3] - which, while maybe outdated, in my opinion are still pure gold.

[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-...

I have the tendency of pick no so-popular options (among the large dev population) but with eye to be as productive and rock-solid for solo dev.

- 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.

PhotoStructure is a self-hosted image manager.

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!

Static Hugo site running on Cloudflare Pages: https://clippyfrontend.pages.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.

Run a hardware based tech startup.

Main Website: wordpress, WooCommerce, stripe

Mobile Apps (iOS/Android): Flutter, Firebase

WebApp: ReactJS, Firebase

Hardware Firmware: C

Not a software company, but photographer.

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

CabinKey - Vacation Rental Management https://www.CabinKeyapp.com

www site is Hugo, served by Netlify

Admin panel is VueJS SPA served by Netlify

GraphQL used to communicate between Admin panel and API

API Node.js running on Northflank (in the middle of switching from Heroku) Postgres RabbitMQ

AWS S3 for some stuff Postmark for email Posthog for some app analytics Metabase for insights into trends

https://northflank.com/

Sveltekit I've only just begun the journey but I'm sold! After trying everything from Smalltalk/Lisp, PHP, ASP.Net and React et al and even bare bones web components, Svelte and Sveltekit has hit a sweet spot for me as a one man band. It handles both server and client side in one app and can be fine tuned to get the most of both server side and client side rendering.

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

I have a side project running https://words.hk (a Cantonese dictionary)

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.

Working on something at the moment more as an experiment that might turn into a product.

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)!

productivity saas app: Frontend: html/css/js (all vanilla) Backend: windows server, c#, .net Database: MySQL Infrastructure: all at AWS (EC2, RDS, S3, Cloudfront, ACM, Route53) Email: postmark Blog en marketing website: static (S3+cloudfront), CMS custom build Monitoring: uptimerobot Ip to Location lookup: ip2location User manual: Manula Payements: FastSpring and 2Checkout Customer support: Freshdesk

For https://apibakery.com (API code generator for Django and Node):

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).

A book publishing pipeline, that's... Overly simple. I see about $5-15/month, which should set your scale expectations.

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.

https://atomictessellator.com

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

Hi, I use Cloud Services (AWS, Azure etc') for a simple machine. Then Caddy as webserver (with https from let's encrypt) phpfpm for the code.

That's it. Very easy.

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

For https://encycolorpedia.com

- 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)

Postgres, Django, and Bootstrap with sprinkles of JavaScript deployed on DigitalOcean App Platform or Dokku.

I can demo my (backend) tech stack while demoing the app itself: https://app.ilograph.com/demo.ilograph.Ilograph/Request

I run a data warehouse for sports data, with a web frontend. Lots of integrations with 3rd party APIs to pull in data.

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

As an intermediate Italian learner (with a native Italian speaking partner) I think its pretty good. The main challenge I have is the speech to text when I speak back in Italian - it doesn't capture what I'm saying very well, often misses words altogether.

I built https://PlotAPI.com with Django, htmx, Alpine.js, and Tailwind CSS. I was new to all 4 of those technologies and learnt whilst on the project, it was a great experience.

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!

Majestic monolith in Go. Server rendered HTML with tailwind UI on recent products. Materialise css on legacy.

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

I don't have a company but whenever I used to work on side-projects that I thought would lead to a company, I would use Laravel + MySQL + VPS. And whenever I worked on projects just for fun, I would use Nodejs + React + MongoDB.

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.

App: Expo, React-Native, Typescript, Apollo Client

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

https://www.Kandoop.com, a productivity platform (better Evernote + Trello + WordPress-ish for custom feeds). It does a bunch of good stuff.

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.

I just wrote something relevant:

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

Frontend: React/NextJS hosted in Vercel (TypeScript + mix of Tailwind & Bootstrap)

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

Real-time PubSub: SignalR

Deployment: GitHub Actions

Rails + Hotwire + PostgreSQL. I am now basically making a template out of this for myself https://businessclasskit.com/.

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 app: c#, .net 6, mvc, postgres, redis, azure, github (repo and actions)

marketing site: hugo, netlify

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

I run https://www.slickdns.com (DNS hosting) and https://www.youpatch.com (pixel quilt patterns).

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)

It depends on your requirements. I have been building www.confluo.app, a social task assistant, in my part-time for about 2 years now. I wanted it:

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).

Python, Flask, Go, Postgres, Redis, SSDB(Redis on SSDs instead of RAM), GitHub Actions, DigitalOcean, WakaQ(a minimal Celery), Backbone.js(love React but it's for bigger teams than me).

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

I keep it simple and stay as much as possible in my comfort zone:

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

We're very much not a company of one anymore, but I used Unicorn Platform for our startups website (http://robusta.dev)

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.

Sveltekit/Tailwind for the main website (hosted on cloudflare)

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

Technically I'm in a company of 50 plus but as the sole dev I think I might qualify.

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.

LAMP.

Linux, AWS, MySQL, Perl

HTML still works it turns out!

A friend of mine posted his one-developer tech startup details here: https://medium.com/dreamwod-tech/how-i-built-my-tech-startup...

Tech stack of Binocs the CLI-first uptime monitoring (https://news.ycombinator.com/item?id=32923326)

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

- Fargate, SQS, Lambdas in AWS

- Docker and GitHub Actions

I have been making money for 14 years with PHP/MySQL/jQuery . I can't remember how old jQuery is, probably started with vanilla Javavscript. I moved from Hostgator web hosting to Hetzner Cloud along the way. My server costs 10 euro per month.

- Firebase for hosting, DB (Firestore), analytics, Cloud functions (NodeJS) - Angular for front-end - Ionic for bundling the Angular app for mobile

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

Building a no-code data workspace

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

I have a wide tech foot print but boring stack.

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.

C# on Azure Functions for backend. Azure managed SQL Server for storage. Azure managed Redis for caching. Azure Application Insights for monitoring. Forest Admin front end.

Quite a pleasant experience overall for what I need.

For my latest project:

Frontend: React/Typescript

Backend: React/Typescript, Nim

DB: Postgres

Hosting: Namecheap, Cloudflare, ZAP-Hosting

Front end: TypeScript, Angular, Apollo, Material Back end: Scala, ZIO, zio-http, Pulsar, Keycloak, Postgres Hosting: Kubernetes on Digital Ocean, GitLab Pages Tools: Hugo, Twilio, Namecheap, Mailgun

Generally do either API + SPA for app like things, or something in between that and full static

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

Main website: bootstrap & vanilla JS.

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.

Rails, SQLite, and Linode.

OS: Ubuntu or Alpine Linux

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.

https://getmagistrate.com runs on Django + Render + Tailwind + Alpine.js + htmx.

Great stack for the solo dev imo.

Rails + mysql, with Sorbet for Ruby type safety React Native for our mobile app Typescript for all JS

Hosted on Linode

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

Sorry for being overdue! I have just asked once a year when I remembered it, love the fact that someone else appreciated it enough to continue asking when I forgot

Microservices architecture with Java Micronaut postgres firecracker Haproxy bash Prometheus+loki+grafana+node_exporter+promtail Frontend: Next.js using typescript

Mostly boring tech: Hetzner dedicated server, .NET 5 web app interfacing with some C++ libraries, Sqlite for database, Jquery frontend. Pull backups with borg

We fluctuate between company of one and company of a handful.

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

I run https://chessmadra.com

React + Typescript frontend

Rust backend

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

I would have imagined PaaS offerings like Heroku (where you get an SRE team for cheap) would be popular, but it seems not. Can anyone explain why?

Home grown crm/erp. Django/mysql started in 2008. Recently migrated to google cloud run. Adding tailwind, htmx, alpine js to modernize.

HTML/CSS/JavaScript - Backend APIs are either in Spark Java framework or Python's Flask

Nice! What kind of sports data? Is it usually enthusiasts who pay for access to this data? How do you charge your customers?

Compliance software B2B

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)

Have a Monitoring Solution product for Solar Plant. Stack - Django, Cassandra, Redis, KairosDB, Celery, Bootstrap, Jquery etc.

Hugo, Go, K8s, PubSub, Vue, Sendgrid, Postgres

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

NodeJS / TypeScript / Express / React / Tailwind / PostgreSQL / RabbitMQ / Docker

AngularJS 1.8 and Falcon Python API backend. Redis and Postgres. Running an 8 figure ARR business on this stack.

Not really a company, just a side project used by me and some friends: Laravel + Unpoly + Tailwind.

Django, considering switching to Flask for more flexibility. The server is running nginx on FreeBSD.

Trying to build a small scaled e-commerce platform like shopify.

Backend: spring boot, kotlin

Frontend: reactjs, nextjs, typescript

Micro services: Traefik + Docker

Web stack: nextjs, symfony or fastapi, netlify

Monitoring: Matomo, metabase, signoz, prometheus.

main language: JavaScript

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

other: Heroku, GitHub

ruby + rails + hotwire + postgres + redis + sidekiq + heroku/DO + docker + dokku

Centos/Postgres/Django/jQuery/Bootstrap.

Linux, HAProxy + Lighttpd + PHP (fpm) + MariaDB + Redis

- Ubuntu VMs at digital ocean

- Nginx webserver

- asp.net / dotnet / c#

- vanilla js

Ionic/Angular with Firebase.

Xojo

AWS EC2 Debian Linux

Let's Encrypt