‍

‍

The setup I use when I don’t want to waste time

‍

Every developer knows this feeling.

‍

You sit down to start a new project, full of ideas, ready to build something useful — and then hours pass before you even get to the real work. You’re choosing a framework, setting up a database, figuring out authentication, fixing environment issues… and somehow the day is gone.

‍

It’s not hard work, but it’s repetitive work. And that’s what makes it frustrating.

‍

After going through this process again and again, you start noticing a pattern. The same problems show up. The same decisions come back. And eventually, you realize something simple: the right stack doesn’t just help you build, it removes half of the work you never wanted to do in the first place.

‍

This is not about using trendy tools or building the “perfect” setup. It’s about choosing a small, practical combination that lets you move faster without overthinking every step.

‍

‍

‍

‍

Starting with the right foundation: Django or FastAPI

The first decision shapes everything that comes after.

‍

If your project involves pages, user accounts, dashboards, or any content-related features, Django makes getting started much easier. It gives you structure immediately, and that structure saves time in ways you only notice later. You don’t need to build an admin panel, you don’t need to rethink authentication, and you don’t need to worry about how everything connects — it’s already there, working.

‍

On the other hand, if your focus is on building APIs or services, FastAPI feels much lighter. It handles data validation automatically, generates documentation without extra effort, and performs well even as your app handlesmore requests. You spend less time writing protective code and more time focusing on what your API actually does.

‍

There’s no need to use both at once. Choosing one based on your goal is enough to avoid a lot of unnecessary complexity.

‍

Choosing a database that won’t slow you down

A lot of time gets wasted trying to pick the “best” database, when in reality, most projects just need something reliable.

‍

PostgreSQL is one of those choices you rarely regret. It’s strong with structured data, flexible enough for more complex cases, and stable in production. You can start simple and grow into more advanced queries later without switching systems.

‍

Instead of experimenting with multiple options early on, sticking with something proven helps you move forward without second-guessing.

‍

Making testing feel natural instead of heavy

Testing often gets ignored, not because it’s unimportant, but because it feels like extra work.

‍

That’s where pytest changes the experience. It removes the friction. Writing tests feels closer to writing normal code, and running them is fast enough that you don’t avoid it.

‍

Over time, this builds confidence in your project. You’re not guessing whether something broke — you know. And that alone saves hours of debugging later.

‍

Keeping your environment under control with Docker

One of the most common sources of frustration is when something works perfectly on your machine but breaks somewhere else.

‍

Docker solves this quietly. It creates a consistent environment where your application behaves the same way everywhere. Whether it’s your laptop, a teammate’s setup, or production, you’re running the same system.

‍

It might feel like an extra step at first, but it removes a category of problems that can otherwise take hours to track down.

‍

Letting your code stay clean without thinking about it

Formatting and small mistakes might seem minor, but they add up quickly, especially in teams.

‍

Using Black and Ruff together keeps things simple. Your code is formatted automatically, and common issues are caught early, often while you’re still typing.

‍

There are no long discussions about style, no messy pull requests, and no wasted time fixing things manually. It’s one of those small improvements that quietly make daily work smoother.

‍

Catching problems early with data validation

Many bugs don’t come from complex logic, they come from unexpected data.

‍

Pydantic helps by validating data as it enters your system. Instead of discovering issues deep inside your application, you catch them at the edge, where they are easier to understand and fix.

‍

This reduces confusion and saves time that would otherwise go into tracing errors back to their source.

‍

Making deployment feel simple, not stressful

For many developers, deployment is the point where everything suddenly feels complicated.

‍

But it doesn’t have to be.

‍

Platforms like Railway remove most of that complexity. You connect your code, push changes, and your application goes live. There’s no need to manually configure servers or spend hours setting things up.

‍

This makes it much easier to actually finish and launch projects instead of leaving them stuck in development.

‍

What changes when you use a stack like this

Individually, each of these tools solves a small problem.

‍

But together, they create something more important — a smoother workflow.

‍

You stop repeating the same setup steps. You spend less time fixing avoidable issues. You don’t get stuck in decisions that don’t really matter.

‍

And most importantly, you get to focus on the part that actually matters: building something useful.

‍

A simple way to approach it

There’s no need to use everything at once.

‍

Start with what you need right now. A framework, a database, and basic testing are usually enough. As your project grows, you’ll naturally feel where things start slowing you down — and that’s the moment to add the next tool.

‍

The goal isn’t to build a perfect stack from day one.
The goal is to remove friction, step by step.

‍

‍

Written by Aram Andreasyan

‍

Industry Leader in Web Development and Design

‍

If you want to read more insights, follow me on Medium.

‍