What's your tech stack?

Personally, I love Laravel + VueJS. It's simple and eloquent and I feel the developer experience has been well thought out. What I love about both Laravel and Vue is the big functionality features that you'd look for are handled first-party through additional packages.

For example, Vue has a native router and state management system that works well with the rest of Vue. Use them only if you want.

Same with Laravel. PHP 8 isn't the gnarly language PHP used to be. Laravel has pushed the boundaries and provided excellent first class package support for larger features such as oAuth, full text searching, etc.

I use this stack on our SASS (http://bugflow.io/) which includes some high availability features that are handled natively through Redis. And in our book, which allows you to use Laravel and Vue to write 1 code base and deploy to web, iOS and Android (https://serversideup.net/ultimate-guide-to-building-apis-and-spas-with-laravel-and-vuejs/)

For Testkit we're using the following:

• Full-Stack Framework: Ruby on Rails - Reason: Easiest to use, has all we need included
• Database: PostgreSQL - Reason: Best suited for our use case in terms of speed, flexibility and performance
• In-Memory DB: Redis - Reason: Used before, happy with it
• Scheduling and Queueing: Sidekiq - Reason: Easy to use, good integrations
• Browser Extension: Angular - Reason: I know this framework best, batteries included
• Git: GitHub - Reason: Most flexible and versatile, easy to use
• Issue Management: Linear - Reason: Easy to use, encourages good development principles
• Browser Management (This includes scheduling browser access on servers etc.): Selenium - Reason: Most flexible
• Browsers: Chrome, Firefox, Safari, Opera, Edge, all deployed on machines on Hetzner - Reason: used before and very flexible, which is needed for this
• Servers and Deployment: Render (apart from browsers) - Reason: easiest to use
• Website: Webflow - Reason: future editing doesn't need code and can be done by almost anyone
• Testing: Well, Testkit itself - Reason: easiest to use, solves our own pain, we find bugs and missing features, UX issues, and problems ourselves without fully relying on our beta users

I think that's the major tech used in my project - hope it helps :)

My business partner and I are working on an email newsletter management product called Presspool. Here's the tech stack a few weeks in:

App: We are using a vanilla Ruby on Rails v7 stack with Turbo and Stimulus, backed by PostgreSQL. My cofounder and I both know Rails pretty well, so it was a low-friction choice to get started, and Ruby remains one of my favorite languages after more than a decade.

As a newsletter product, we rely pretty heavily on ActionMailbox and ActionMailer in Ruby. We're using on-disk storage on Render to back ActionMailbox for now, but are planning to move to an S3-compatible option like DigitalOcean Spaces before launching more broadly.

Hosting: We have used Heroku extensively in the past, but we're trying out Render this time around. It's been easy to work with so far, and we really like the automatic preview environments for branches/PRs.

Analytics: We are pro-privacy / anti-tracking, so we want to keep analytics as light as possible while allowing ourselves to learn. During beta testing, we're thinking about using something like FullStory with clear opt-in from the beta testers to work through usability issues, but we're planning to switch over to something like Plausible or Fathom Analytics for a broader rollout.

Happy to answer any other questions about our stack or provide updates as we continue to make progress!

Currently building a stock discovery/meta-market analysis algorithm called feetr.io.

I know that I'm most likely in the minority here but I use Common Lisp (SBCL) for front and backend.

I use Hunchentoot for the backend, Spinneret for HTML generation, Jonathan for JSON parsing and encoding, and Postmodern for Postgres interaction. All of this behind Caddy.

I think that Lisp has a lot of benefits for solo developers but, for me, it's just fun to write. I do appreciate the fact that I can rewrite the language itself in order to make constructs better fit the problem domain. Also, connecting to a running program and editing and recompiling it on the fly is insanely powerful.

Outside of that, I'm currently using AWS and migrating my emails to Postmark. AWS just because it's there and it works well enough for me, and Postmark due to Sendgrid having a pretty terrible reputation on Hacker News (unsure how true it is but I'm not willing to take the chance). Probably Stripe for subscriptions. Maybe Square. Bitcoin at a later date.

angular nestJs Mongodb

I am building a place online where bootstrappers can find each other and work together. It's called the WBE Space and my tech stack is HTML, JS and Python

For my school timetabling app Schedula: (https://schedula.io)

App frontend: Vue
App backend: NestJs, Postgres, Redis
Marketing site: Next.js + Cloudflare pages
Infra: Kubernetes + DigitalOcean

Keenforms is Ruby on Rails and React. We use React on Rails gem which has been fantastic.

For Pin garden (https://pin.garden) I'm using Laravel with Vue (via Inertia.js).
I've also tried Tailwind because with this stack it's pretty much the standard, although I usually prefer a more classic approach to CSS.

All hosted with DigitalOcean App Platform.

I chose this ecosystem because I'm comfortable with PHP and there's a very active and friendly community around Laravel.

Im currently building Interact List - It's a free WebApp that lets you share and embed interactive checklists to strengthen your products and service, currently in Private Alpha. I will be launching Public Beta soon. The full stack is built using AWS Amplify with NextJS. The reason I went with this stack is to focus less on infrastructure (serverless), and instead invest the time into making Interact List a great user experience. Another great benefit of AWS Amplify is that it is future proof in terms of scaling (lambda, cloud functions, CDN etc)

The full stack

Front end

• NextJS framework (ReactJS)
• React-Bootstrap components
• DraftJS Editor

Back end

• Served and configured via AWS Amplify
• NextJS (API's and a mixture of Server side rendered (SSR) pages and statically generated (SSG) pages)
• MongoDB Cloud

I'd love to hear your thoughts, and if you like the project, please subscribe to be notified for beta

PHP + postresql + nginx

Don't have a frontend app.

It is always interesting to read those comments from time to time. I am always fascinated by how diverse the tech stacks are. Sooo many different ways to go.

For small static pages/apps, I am using Pug, CSS (mostly Bulma or Pico.css), and plain JS. Always with Prepros.io. I also created a little boilerplate called Nagediy on GitHub, feel free to check it out.

For larger projects or more dynamic apps, I bet on Kirby a flat-file CMS hosted on a Hetzner VPS instance. So in general my tech stacks are very simple and lean IMHO.

For SheetDream: React, TypeScript, MongoDB, Node.js, RabbitMQ, Redis, Docker (Dokku hosted on DigitalOcean more specifically), Git

For my latest project (not released yet!): React, TypeScript, TailwindCSS, Netlify, and Firebase

I built onesentencejournal.com with Django/Python, PostgreSQL, and Bootstrap. Hosted on a Linode VM.

It's a simple stack that I was already familiar with.

Hey! Founder of https://atomcal.com/?src="ih" here, my tech is pretty simple for the backend, where I use NodeJS with Mongo DB. However, I have a different authentication server that uses NodeJS with MySQL because it is interlinked with a CMS.

On the front, the CMS uses ember and HBS templates so I had to learn that, but the main app is built using create-react-app with recoil as a state management library and Dexie DB (indexedDB) for frontend data storage and management.

Would love to know what you think, and if you have any questions on how it all works :)

At the moment, I'm learning towards Gatsby/TypeScript/MDX and Django/Postgres.

Gatsby is especially good for building content sites from a variety of data sources. You get the SEO friendliness of pre-rendered HTML along with the performance of an SPA.

TypeScript makes writing JavaScript much easier and less stressful.

MDX makes it easy to create dynamic content with markdown files.

Django is a solid full-stack framework. Python is a good choice, because it has a wider range of uses than languages like PHP and Ruby.

Eleventy + Parcel is another interesting framework that I've been experimenting with.

It depends on the project. I have recently discovered init.tips and it's pretty much become my favorite "stack".

For Pingparrot I rely on Blitz.js for both the frontend and backend. To query the Postgres database I use Prisma. To send emails I use Mailgun. To host everything I use Railway.app

I tend to use Django, Caddy with SQLite, made durable with the help of Litestream. Dockerize it , GitHub actions that deploys to Linode or Digital ocean. https://www.tigersandtacos.dev/posts/django-with-sqlite3-made-durable-with-litestream-and-caddy/

My tech stack is changing constantly, but at the moment I'm using the following:

• Laravel for creating APIs
• MySQL for database
• Redis for caching / queue driver
• React or Next JS for frontend framework
• Tailwind CSS
• Cypress for testing
• GitHub for versioning and automation
• AWS for hosting

I feel I'm most productive with this stack, but I'm always evaluating other options out there. I've been playing around with Remix lately as a JavaScript framework and like what I'm seeing so far.

Symfony Framework built on PHP 8.1 with GraphQL API

Quasar Framework built on Vue Js for frontend

Rails + React + AWS + MySQL
That's what I know & comfortable with.
My day job teaches me enough about tech so I don't mix learning & gigs

For a Shopify app I am working on I am using Nextjs for UI and API, deployed on Netlify + PlanetScale for database. I can’t recommend Netlify enough, the developer experience is amazing and their free tier is very capable.

We're using Svelte > Vercel > Supabase on our product MoodFirst:
https://www.moodfirst.ai/

We started off on a no-code platform called Bubble.io which was really good to get started and create an MVP but we eventually decided we need something more flexible.

We evaluated quite a few different options (Firebase, Fauna, AWS) but settled on Supabase as the back end because a) Relational database b) Auto-generated API c) Integrated authentication.

We had some good feedback on our options in this thread:
https://www.startupschool.org/posts/44079

My personal projects/contracts: Laravel, Vue.js & TypeScript

At work: NodeJs, React, TypeScript, Apollo & MongoDB 😖

I use Vue.js for powerful UI capabilities, because my product (https://kaado.io/) lives and dies with smooth UX. I think any decent JS framework would do here.

Backend is supabase, which is really good for simple database structure like mine because it allows a no/low code backend.

We use NextJS, MongoDB and Digital Ocean for Blogbeagle :)

Funnily enough: WordPress and Haxe (nobody knows haxe, don't worry ;)).

I have a product where you can make and share RPG games. So on one hand I have the application to make RPG's, and on the other hand the community website.

App is done in Haxe (haxe.org) because I want it to be platform independent (for the future), and it's known in game dev circles.

For the community website, I use WordPress and am very happy with that! I started using that because I wanted something quick, but now I run everything on that and haven't looked back.

It's basically: I want an XYZ, no problem, there's a plugin for that!

• forum
• social features with activity feed
• comments on games
• newsletter
• tracking premium sales
• analytics integration
• ...

Tailwind + Alpine.js

All my projects are here.
https://apesoflondon.studio/

For instadeq I use Elixir + Cowboy on the backend and JS + React + Bootstrap on the frontend.

Deployed on Digital Ocean.

Why? Simple, I know the tools and Elixir being built on top of the Erlang VM handle concurrency/websockets really well.

I wrote a more detailed guide on my frontend setup here: A Simple, Understandable Production Ready Frontend Project Setup

Used to... but maybe again soon...
This is for B2B.
Java spring, keycloak for logins, nginx, react spa based on react admin framework.
I had something that almost got to production before i stopped - rabbitmq for inter service communication and spring batch (heavily customized) for job execution and management. It must be a strong reason to split to multiple services I can tell you that. Very complicated and error prone.

For Ready Planner I use NextJS + React + MUI + Firebase.

Why?

I use Firebase's fast CDN to host static pages generated by NextJS. The static pages are not "static" in that NextJS creates a MPA. So whichever page the user lands on all subsequent routing is on the client. This gives you all the benefits of SPA plus the SEO.

Firebase's Firestore and cloud functions are very easy to use and enable a lot of complex use cases like reacting to DB actions. Firebase also has a lot of features for the entrepreneur, like A/B testing, Authentication, Object Storage, and more.

MUI is a ready to use component library based on Google's Material UI. It provides battle tested design and interactions out of the box but also easily allows for adding your own theme on top of it.

just Deta.sh for deployment, database, server. Amazing

my recent product is built on: firebase, react and tailwindcss

Infra:
AWS Lightsail Virtual Machine

API:
Postgres, Kotlin and Ktor

Frontend:
Typescript, NextJS

Node backend talking to Postgres - nice and minimal, will be easy to scale.

React frontend - something I'm familiar with, works particularly well for a heavy client side product.

Hosted on DigitalOcean App Platform - simplifies configuration, cheap, and again easy to scale

Rails on Heroku with Postgres and Redis.

The first rule of bootstrapping is to build with the technology you know. I’ve done nothing but Rails for the past 17 years so it’s naturally what I choose.

For the app: Rails running on Heroku (incl. the usual Postgres, Redis, ...) and some other SaaS around it. Why? Because it is super stable, established, has a great support community and does not require tons of mind share (like e.g. the node.js universe)

For the website: Tailwind-based templates generating a static site with 11ty, deployed to Netlify. Again, super simply, very fast, just works.

We are building Daito (https://www.daito.io), which is a web-based 2FA Authenticator to enable sharing of 2FA tokens in small and large teams.