r/flask

Which is best Laravel or Flask

built this for flask + SQLAlchemy codebases because existing SQL linters only see .sql files, which is useless when the SQL doesn't exist until runtime, or they are AI garbage tools

valk-guard reads the python AST, walks SQLAlchemy chains (session.query, select, filter, join), reconstructs the SQL the ORM will generate, parses it with a real postgres grammar, runs 19 rules. catches DELETE/UPDATE without WHERE, SELECT *, leading wildcard LIKE, CREATE INDEX without CONCURRENTLY, plus schema drift between models and migrations.

deterministic. no LLM, no DB connection. runs in CI in seconds.

postgres only. SQLAlchemy 1.x works, 2.0 mapped_column half-done+ SQL migration file

https://github.com/ValkDB/valk-guard

would appreciate feedback from anyone running flask + SQLAlchemy in prod, especially on patterns you think this would miss.

Hey everyone,

I just finished my CS50 final project: VORTEX.

It’s a Flask-based e-commerce website I built for a real clothing brand project owned by a friend of mine, and it’s already running online with a few products.

GitHub: https://github.com/bassam-alaraby/vortex

Main things I used/worked on:

• Flask
• Turso database
• Cloudinary uploads
• Telegram order notifications
• Admin dashboard
• CSRF protection + rate limiting
• Vercel deployment

Before CS50, I honestly never thought I’d be able to build something like this from scratch. Working on a project that people can actually use made me learn way more than I expected.

Took me way longer than I thought honestly 😅 but I’m really happy I pushed myself to finish it.

Now that I’m almost done with the course, I wanted to ask: What do you think is the best next step after CS50?

I also wanted to ask: What exactly should I do next to officially complete CS50 and receive the certificate?

Also, if anyone has feedback on the project or code structure, I’d really appreciate it. Still a lot to improve obviously.

I built sqlalchemy-query-manager, a small package that adds Django-style query ergonomics on top of regular SQLAlchemy models.

I wanted this for backend apps where I kept writing the same filtering, relationship lookup, eager loading, and CRUD boilerplate.

Example:

items = (
    Item.query_manager
    .where(
        Q(is_valid=True) | Q(number__gt=100),
        group__is_active=True,
    )
    .select_related("group")
    .order_by("-number")
    .limit(20)
    .all()
)

What I tried to keep:

• regular SQLAlchemy models underneath
• no replacement for SQLAlchemy
• readable app-level queries
• inspectable SQL

Main features:

• Q objects
• Django-style __ lookups
• relationship filters
• select_related / prefetch_related
• CRUD helpers
• aggregates
• raw SQL helpers
• SQL query preview
• sync and async support

Source code: https://github.com/ViAchKoN/sqlalchemy-query-manager

Question: would this be useful in your cases?

Any feedback or criticism would be appreciated.

Which is best tell me Flask ya Django. Currently i am learning flask

I spent years using my office laptop for personal things alongside work. When I finally needed to move everything to my personal machine, I couldn't find a tool that was simple enough — so I built one.

What My Project Does

laptop-file-transfer-pro is a single-file Flask web app you run on the receiving machine. Any other device on the same WiFi opens the URL in a browser and can drag & drop files directly across — no installation, no cloud, no accounts needed on the sending side.

Also, in later years, everything got blocked on office laptop - cloud, personal email access, USB, network sharing, no outbound email etc.

Key features:

• Drag & drop upload with a real progress bar (XHR with onprogress, not a fake spinner)
• Upload multiple files in one request — large file support up to 4 GB by default
• File listing with size, upload date, download link, and one-click delete
• Extension whitelist + werkzeug secure_filename (path traversal protection)
• Duplicate filenames get a timestamp suffix instead of silent overwrite
• Optional Basic Auth via two environment variables (LFT_USERNAME / LFT_PASSWORD)
• Structured logging — every upload, download and delete logged with client IP
• /health endpoint returning JSON status
• All config via environment variables — no code edits needed
• Zero frontend dependencies — pure HTML/CSS/JS, works on any device
• 30 pytest tests

GitHub: https://github.com/learneramit2020/laptop-file-transfer-pro

Target Audience

Personal / home use on trusted local networks. This is not a production tool — it uses Flask's built-in dev server and has no HTTPS by default, which is fine for a home WiFi transfer between your own machines but not for anything internet-facing.

The target user is someone who needs to move their own files between two machines on the same network and wants something they can clone, run in 30 seconds, and trust because the code is short enough to read in one sitting (~350 lines including the HTML template).

Comparison

Tool	Requires install on sender?	Cloud involved?	Progress bar?	Open source?
laptop-file-transfer-pro	No (just a browser)	No	Yes	Yes
Snapdrop / PairDrop	No	Relay server	No	Yes
Python http.server	No	No	No	Yes
Wormhole (magic-wormhole)	Yes (CLI)	Relay server	Yes	Yes
Syncthing	Yes	No	Yes	Yes

The closest comparison is python -m http.server, which is what most developers reach for. The differences: http.server only serves files from the machine it runs on — it can't receive uploads. This app is specifically built for the upload direction, with a UI, progress feedback, security hardening, and a proper extension whitelist.

PairDrop/Snapdrop are excellent but route traffic through a relay server (or require self-hosting). This app is purely point-to-point on your LAN — nothing leaves your network.

Syncthing and magic-wormhole are more powerful but require installation on both machines. This needs nothing on the sending side beyond a browser.

This is also my first published GitHub project — happy to take feedback on the code, the approach, or anything else.

jokes aside i am trying to build a reactive gui based on flask, partials, jinja and tailwind. so far i have some event loops working, its called shadowgui, follow me, to see when i make it public.