TaskCart's self-hosted Docker Compose architecture offers PaaS alternative

This review examines TaskCart's detailed infrastructure breakdown, focusing on its custom VPS deployment, Docker Compose setup, and specific configurations for PostgreSQL and a dual-Redis strategy.

TL;DR

Best for: Teams seeking full control over their production environment, aiming to reduce PaaS costs, and comfortable with managing their own Dockerized infrastructure. Skip if: You prioritize managed services for databases and caching, lack in-house DevOps expertise, or require instant scalability without manual intervention. Bottom line: TaskCart's setup demonstrates a robust, cost-effective self-hosting strategy for SaaS applications, trading PaaS convenience for granular control and potential savings.

METHODOLOGY

This v0 review draws on the founder's published claims in a Reddit post by user lampropoulosss, titled "We ditched PaaS to self-host our new SaaS on a custom VPS. Here is our production Docker Compose & infrastructure breakdown," accessed on Reddit on May 23, 2026. The review covers the founder's stated rationale for self-hosting, the specific Docker Compose architecture, and the detailed configurations for PostgreSQL, Redis, and backup solutions. What's not covered in this initial review includes independent performance benchmarks, long-term workflow implications, security audits, or edge case handling. Update cadence: re-tested when claims diverge from observed behavior.

WHAT IT DOES

TaskCart, a new SaaS product by two developers, offers an all-in-one workspace designed to help freelancers replace fragmented tools like Trello, Stripe Billing, and Dropbox with a single dashboard. The founders opted to self-host their entire production environment on a custom Virtual Private Server (VPS) to avoid PaaS lock-in and associated costs from providers like Vercel or AWS. Their infrastructure is built around a highly resilient Docker Compose architecture.

App cluster and load balancing

The application's frontend and backend are developed using SvelteKit (Node.js 20). TaskCart deploys four replicas of its application container, built with a multi-stage Dockerfile based on Alpine Linux for a minimal image size. An Nginx container acts as the ingress reverse proxy, exposing port 443 and load-balancing incoming traffic across these four Node.js replicas.

Database and state management

TaskCart utilizes PostgreSQL 16 with a persistent pgdata volume. The database is specifically tuned for the VPS environment using custom flags: max_connections=200, shared_buffers=512MB, work_mem=16MB, and effective_cache_size=1GB. A key architectural decision is the dual-Redis strategy. A "Primary Redis" instance is dedicated strictly to BullMQ queues (for sending emails via Nodemailer and generating PDF invoices) and session state, configured with AOF persistence (--appendfsync everysec) to prevent job loss if the container restarts. A separate "Cache Redis" instance is used purely for caching, with a strict 512MB memory limit and an allkeys-lru eviction policy. This separation aims to prevent cache evictions from impacting critical background jobs.

Deployment and automation

For zero-downtime database migrations, managed by Drizzle ORM, an ephemeral container runs drizzle-kit push as a pre-flight step. The four app replicas are configured to depend_on this migration script's successful completion before they spin up. Automated off-site backups are handled by a custom Docker service that runs exclusively in production. This service routinely connects to the Postgres database, creates SQL dumps, and securely pushes them to a remote Cloudflare R2 bucket, which is S3-compatible. It also manages retention policies, keeping seven daily and four weekly backups. The team also hosts internal DevOps tools like Adminer on their virtual network for monitoring without public exposure.

WHAT'S INTERESTING / WHAT'S NOT

The most interesting aspect of TaskCart's setup is the explicit rationale for self-hosting. The founders clearly articulate their desire to avoid PaaS lock-in and reduce costs, a common motivation for smaller teams or those with specific performance or security needs. This isn't a vague "we like control" statement; it's tied to specific financial and architectural independence goals. The detailed docker-compose.yml breakdown provides a concrete blueprint for others considering a similar path, moving beyond abstract discussions to a working production example.

The dual-Redis strategy is a pragmatic solution to a common operational problem. Separating critical queue and session data from volatile cache data with distinct persistence and eviction policies demonstrates a thoughtful approach to resilience. The custom pg-backup service, pushing to Cloudflare R2 with defined retention, is another strong point. It addresses a critical operational need (disaster recovery) without relying on a managed database service's built-in backup features, aligning with the self-hosting philosophy. The use of Drizzle ORM for migrations with a depend_on pre-flight container is a solid pattern for ensuring database schema consistency before application startup.

What's less detailed, though not necessarily "not interesting," is the lack of specific performance metrics or cost comparisons. While the founders state they want to avoid PaaS costs, they do not provide a direct comparison of their VPS cost versus an equivalent PaaS setup. This makes it harder for readers to quantify the "associated costs" they are avoiding. The mention of internal DevOps tools like Adminer is good, but the post does not elaborate on how these tools are secured or integrated into a broader monitoring and alerting strategy, which is crucial for a self-hosted production environment. The resilience claims are based on architectural choices (replicas, AOF persistence), but real-world failure scenarios and recovery times are not discussed.

PRICING

The Reddit post does not specify pricing for TaskCart itself. The founders state their motivation for self-hosting was to avoid the "associated costs of Vercel/AWS" and PaaS lock-in, implying cost savings compared to managed services. Pricing snapshot date: May 23, 2026.

VERDICT

TaskCart's self-hosting strategy, detailed through its Docker Compose setup, is a strong choice for teams prioritizing control and cost efficiency over the convenience of fully managed PaaS solutions. The dual-Redis approach for separating critical jobs from cache, combined with robust PostgreSQL tuning and a custom Cloudflare R2 backup service, demonstrates a well-considered, resilient architecture. This setup is best for developers with strong DevOps capabilities who want to avoid vendor lock-in and optimize infrastructure costs. It is not suitable for teams that prefer hands-off infrastructure management or lack the expertise to maintain a production-grade Dockerized environment. The explicit architectural decisions provide a valuable blueprint for others navigating the build-vs-buy decision for their infrastructure.

WHAT WE'D TEST NEXT

Our next steps would involve independently benchmarking the performance of TaskCart's Docker Compose setup under various load conditions, specifically focusing on the impact of the Nginx load balancer and the PostgreSQL tuning parameters. We would simulate database failures to assess the effectiveness of the AOF persistence on the Primary Redis and the recovery process for the PostgreSQL database using the Cloudflare R2 backups. A detailed cost analysis comparing their current VPS expenditure with equivalent PaaS offerings (e.g., Vercel for frontend, a managed PostgreSQL service, and a managed Redis service) would quantify the claimed cost savings. We would also investigate the security posture of the internal DevOps tools and the overall network configuration, including firewall rules and access control, given the self-hosted nature.