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.

If you stick with the core product and set a very high bar for which plugins you install, Wordpress is rock solid

But you have to ask yourself the question what is most important:

1. A full featured system that is popular (because it's full featured), but might have higher risk on security.

1. A limited system that is less popular (because of the limited features), but has a high regard on security.

Anyway, I don't store personal information and have regular backups. So when the worst hits the fan, I would still be able to recover from that.

You have to ask the question how important security is relative to all the other things. Once I would have ingame currency for example, I will need to beef up my focus on security. But for now, I accept the trade-off.

But plug-ins are the reason for using WP and this is often touted. Then people get criticised for using plugins? Indeed the post you’re quoting mentions lots of plugins!

I’ve only very lightly used WP over the years but /every/ plug-in seems suspect

I didn’t work with PHP since 4 to 5 days and honestly I never feel OK with it personally but always admire two things. First Drupal, second Wordpress.

Yes, wordpress is wonderful if you don't have to write your own plugins and themes yourself. But if you do, you'd wish you were using something else though. You pay for those extensibility, backward compatibility and huge plugin ecosystem by sacrificing developer experience.

Like everything, it's always about trade-offs.

To be honest, I don't know if wordpress can improve their developer experience without killing the golden goose.

What is bad about laravel for development experience? I don’t like php or js or, dare I say it, ts (I don’t mind the language and like the type system but the tooling is so rotten; hope deno will fix things), so I often experiment in projects by taking something else like Phoenix, IHP or Dioxus etc and it’s nice, but you always run into the lack of help when stuck. I did a large project with a team with laravel the past months and was really surprised how productive it is; we did basically the impossible in a very short time. Mostly because plug-ins and the bizarre amount of capable people willing to help all over the place.

Still don’t like the language but it’s very productive and robust imho.

Wordpress I did quite a lot with as well but I will never like it; it is too messy to be clean and too clean to be a mess; it doesn’t fit my way of thinking either way.

I feel real joy not having to use JS for anything though; things like liveview/livewire/blazor/dioxus etc really make my life better.

As a CTO/developer who works with Ruby/Rails and hates php, I think you made the best choice! Especially as a solo who needs these types of “auxillary” functionality. Wordpress is crazy productive in this way. Their plugin ecosystem, ease of upgrades, admin interface with roles is amazing. And the extensibility using filters and hooks is insane. I sometimes wish other libraries could offer this customization abstraction, even though it’s hard to reason about hooks and filters and it’s weird to get used to. But so powerful.

I was kind of lucky that my brother in law has a software development firm in Slovakia. So I hired one of his employees with the agreement that I would just pay for his time, and there are no deadlines. That means this developer could work on my stuff in between their other projects (which do have deadlines). This way I could get a good deal on the rate.

My fail plan was to follow him up closely, and if he didn't deliver the first week I would be able to pay for his time and don't request more work (don't want to get in arguments with family ;)). But it all went great!

For you, I would try out someone and give them a tiny thing to start with. If they can deliver, let them do more. Since you're a developer you should be able to judge their work. That way you limit the loss when it doesn't work out.

As a developer, WordPress makes you feel miserable if you ever worked in any other framework/ecosystem. That's my experience at least.

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

edit: or find previous conversations with high similarity

There's an embeddings API for text/code/images that can bed used for the similar snippets stuff if you bring your own vector search engine like milvus etc, but eventually I'll support uploading sets of documents and do the finding relevant snippets behind the scenes so you can ask these kinds of questions e.g. so people can do custom site specific FAQ answering bots etc.

There's an example in the playground of shorter autocomplete which is another way of helping agents too that it supports

Was thinking of ways to do that kind of thing, I think unified IO is a good start at some flexibility but still lots of peices missing.

In the world of video training your own video filters based on editing a few frames is quite common E.g. something like nuke copycat or using ebsynth etc.

There's likely some new wave of DSLs or visual workflow builders coming that are either more ml friendly and or specific to building a conversational system/ image editing pipeline etc

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.

Kudos!

Checkout https://caddyserver.com , auto SSL, fast and simple.

I tried Caddy (on my robot vacuum!) and it was a breath of fresh air.

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

curios to know more on this - what you could do better using Lua logic?

When the next HTTP request comes in to view that object, I lookup the object's date in the shared dict. If the modified date is > now(), I set the bypass flag to 1, so nginx updates its cache.

From docs:

Parameters of caching can also be set directly in the response header. This has higher priority than setting of caching time using the directive.

    The “X-Accel-Expires” header field sets caching time of a response in seconds. The zero value disables caching for a response. If the value starts with the @ prefix, it sets an absolute time in seconds since Epoch, up to which the response may be cached.
    If the header does not include the “X-Accel-Expires” field, parameters of caching may be set in the header fields “Expires” or “Cache-Control”.

You can figure out where the item is in the nginx cache directory and delete it. But that is complicated by the fact that your app and nginx run as different users. Or you can send a specially crafted HTTP request to nginx assuming you have some kind of backdoor proxy_cache_bypass setup. But that's ugly too. You either have a race condition, or you have to hang your app's response until the invalidation request completes.

If there's another way to evict an item from the cache, I'm all ears.

> When the next HTTP request comes in to view that object, I lookup the object's date in the shared dict. If the modified date is > now(), I set the bypass flag to 1, so nginx updates its cache.

I see it exact as stock behavior and asking what the difference Lua logic brings here.

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

- Very slow compilation times. A medium-sized app can take 30s to build incrementally on a fast desktop computer. And that's just way too slow for front-end development where fast iteration is key. In comparison, Rescript takes maybe a few hundred milliseconds on an app that's about the same size.

- Poor abstraction mechanisms, for making reusable and configurable components with more than a few properties, some being required and some being optional. The common Rust solution for this is the "builder" pattern, which is very verbose to implement, and still quite awkward if you have more than a few required properties.

- Poor debugging ability. WASM is opaque and there's no debugger for it as far as I know. The stack traces you get from Rust is also very noisy and imprecise. You basically only get the function name, and have to search for it in a big noisy stack trace. And because of inlining the problem might not actually even be in that function. Also, when a panic happens the app just freezes. There's probably some way of intercepting and overriding this behaviour, but by default it's quite bad UX.

- The cognitive overhead of manual memory management. Fighting the borrow checker and having to always think about who owns what and what strategy to use to manage data ownership is just completely unnecessary for most front-end development. Most of the time the app is just waiting for an event to happen, and when something does happen the processing needed tends to be dwarfed by the time spent by the browser to update and render the DOM.

- Large bundle size. Because you tend to use native Rust libraries instead of binding to non-idiomatic and often poorly designed browser APIs.

- Somewhat poor browser support? We've had some issues with the app simply failing to load after a new version is deployed, and having to clear the browser cache in order to fix it. We've yet to reproduce this reliably and therefore still haven't been able to track down why it happens.

I find Rescript to be much more enjoyable for both hobby and production use. If you're looking for a front-end language that is quite similar to Rust, just without the manual memory management :)

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

At least thats been my experience with it ~3months back. I was familiar enough with elixir/phoenix/channels to source dive and figure out whats happening, and today i know liveview well enough to avoid the weird interactions, but I imagine it can be a pretty miserable experience for beginners to start with.

At first I had validation on an email input field after a day all text is put through.. I'll have to look into it next week.

The validation lines are still in de code but don't seem to work. It's probably something stupid.

For now the website is live. I used a single db table for everything. Later I'll do it the proper way. I couldn't find an easy example how to add more complex systems.

I used gen.auth and this comes with multiple tables. I guess there is a way to gen it in ecto. But is there also a gen for a basic liveview crud, which can be changed. This way new users start with something, otherwise you start from a void.

I'm not going petal yet. I'll first try without A. I'll probably have to use it in a month when I have to integrate a js library(Html5-QRCode).

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.

- Typescript is a compelling alternative combined with Cloudflare Workers for backend. Cheap and unlimited scalability while not dealing with servers just sounds too good. Database side is not there yet, but I believe it'll come soon.

I know that there are other solutions using Docker for scalability, but it becomes expensive. v8 is what made this possible, and it'll only continue to get better as it's one of the most used software in the world. Python will never get that kind of effort.

- C# and .net 6 is another strong contender today with cross platform support and Microsoft's new open source approach. I'm currently rewriting one of the apps in c# for an enterprise contract and using reflection and code generation, I can do most of the things that I use metaprogramming in Python. And compared to Python, it's a lot faster and I can use things like multi threading without much effort.

After happily writing in dynamically typed languages for 10+ years, I'm slowly moving towards static typing.

Some follow up questions/comments:

JS and therefore TS is the a key programming language of the internet. Where would you learn Typescript today if you would start from scratch? Is learning JS necessary for that?

Interesting to hear about your choice to opt for a dive into the .NET ecosystem. Would you consider F# a wise choice here, or is it better to forgo it and stay on C# for good?

I prefer "Learn x the hard way" style of learning for beginners, but no idea about resources for TS. When I'm learning a new language, I first read about the language to map the concepts I know to the paradigms of the language, look up style conventions, then just start building.

Re: C#/F#

The contract I'm on requires using C# so I don't have a choice in here. But I'm planning to explore F# more after this. The main reason of me going into .NET is almost all government software purchases where I live requires .NET and C#, and I want to tap into that market for new opportunities.

thanks a lot for your hints and comments. Will look into "learning the hard way". Much appreciated!

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

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

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.

Main Website: wordpress, WooCommerce, stripe

Mobile Apps (iOS/Android): Flutter, Firebase

WebApp: ReactJS, Firebase

Hardware Firmware: C

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

For example I was photographing a horse show last weekend, and I have around 3000 pictures and 30 participants.

I used to do that "by hand" with a SaaS, it would take me a full day. I did talk with them to get access to their existing API, but they kept saying they didn't have an API... Stupid.

Now instead, the "generating and uploading" galeries itself takes a single command, and I can use the spare time to sort pictures, be nicer to the customers and take more pictures :)

Especially when dealing with high profile individuals and want to generate individual galleries.

It's possible I'll make it publicly available one day, but seeing my track record, I probably won't too :p

Maybe have a look at digiKam. It can generate HTML galleries and is the closest thing I could find to my use case. It takes a bit of tinkering, but you can generate nice stuff.

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/

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

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

We currently use Postmark but are considering switching to SES to save on costs.

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.

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

That's it. Very easy.

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

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

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

What happens if you lose your IP address (your ISP changes it), do you lose access?

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!

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

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.

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

We’re have a community only in France for now so the website is in french. It will be translated soon.

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.

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

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.

marketing site: hugo, netlify

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

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)

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

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

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!

- 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

I wrote a Nim web framework that has an ORM: https://github.com/jfilby/nexus. However I mainly use the ORM with the back-end engines. You could write a Django-style web app with Nexus + Nimja, but it's difficult to compete with the huge ecosystems of React and Flutter.

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.

Great stack for the solo dev imo.

Hosted on Linode

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

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

Would you suggest something alternative? AWS?

- Nginx webserver

- asp.net / dotnet / c#

- vanilla js

Also when you think from a 1 man operation, I don't need to think about scaling, certs, auth (much), etc. It's common enough I can hire a freelancer to work on a new feature.

I do miss though the raw simplicity of bottlepy, cork and jinja2 templates which was my old stack.

AWS EC2 Debian Linux

Let's Encrypt