Hello Everyone,

Many of you may not know this but many of the people in this world does not have a laptop or computer they can use. Also most of the daily use computers are for just lightweight office work and most of them run windows. But all of the real servers run on linux. We cannot learn something properly without doing that. Also many may provide a webhosting platform but things like bot hosting doesn't come free.

Now to solve the problem I've built Rconsole. It gives linux development environment for free. It is practically a website built in Flask(python). It let's you run commands in the host shell. I highly suggest using render for it. Many of you may wonder about the restrictions in the render. To bypass that you will have the options to install a linux vm with the help of proot that provides almost full linux environment. The current options are arch, kali, debian, ubuntu, alpine.

For consistent data and storage that is also possible but to know about that you have to see the project yourself. It also has an inbuilt file editor, file Explorer. You can upload files/folder directly and also compress/decompress, see properties in there.

There a ton of features in there. So kindly check it out. It also let's you run free bots, websites and things like those.

Repo: https://github.com/Salehin-07/rconsole-ark

Docs: https://salehin-07.github.io/rconsole-ark/

Wiki: https://github.com/Salehin-07/rconsole-ark/wiki

Discussions: https://github.com/Salehin-07/rconsole-ark/discussions

Issues: https://github.com/Salehin-07/rconsole-ark/issues

Hello Everyone,

Just updated the project and now you could have a near unlimited storage, kind of.

Added:

1. Now you could actually use a github repo(private/public) as the storage, and also bypass the 100 mb limit of a single file by storing it on parts and merging on demand.

2. Caching improves the speed by a lot.

3. Have option to store the data encrypted or decrypted

4. Added option to fully change all of settings from the dashboard except few security ones.

5. Anyone can still use the host as storage. Fully changeable from the ui.

Thanks.

Repo: https://github.com/Salehin-07/rconsole-ark

Docs: https://salehin-07.github.io/rconsole-ark/

Wiki: https://github.com/Salehin-07/rconsole-ark/wiki

Discussions: https://github.com/Salehin-07/rconsole-ark/discussions

Issues: https://github.com/Salehin-07/rconsole-ark/issues

Universities spend lakhs on wall-mounted biometric kiosks that create 10-minute morning queues and still suffer from proxy punching.

I built PrezScan (https://prezscan.onrender.com/) using Python/Flask + browser WebGL so teachers can verify check-in/check-out directly on their own phone in under 200ms without extra hardware.

How the pipeline works:

1. Client-side facial normalization & matching: 68-point landmarks -> 5-point affine roll/scale alignment onto a 150x150 patch -> CLAHE dynamic contrast balance (handles dark/backlit hallways) -> 128D embedding vector running on WebGL F16 shaders.

2. Anti-proxy double lock: Attendance only succeeds when connected to the assigned academic block's Wi-Fi subnet (CIDR) AND with active device GPS coordinates (enforced server-side).

3. Zero-score-leak responses: Rejected scans only tell the user to retry in better lighting, never exposing distance scores or thresholds.

4. Native device biometrics: Supports WebAuthn passkeys (Fingerprint / Face ID) alongside SQLite WAL + async Supabase sync and 1-click monthly Excel exports.

Live portal: https://prezscan.onrender.com/

Architecture & benchmarks: https://prezscan.onrender.com/about

Happy to answer questions or get feedback on the Flask + WebGL setup!

Hello Everyone,

Is there a platform other than render that provides free hosting. It should be free and shouldn't ask for credit card infos. If there is something that hosts docker for free like that that will also do. Anything like that? The main goal is not needing a credit card.

I kept wanting to show people Flask apps that only ran on localhost, so I built hoist. hoist up . --cmd 'flask run --port $PORT' runs the app as a service that survives crashes and reboots, and gives it a public HTTPS URL (Cloudflare Tunnel) plus a QR code in the terminal.

Push-to-deploy from git, rollback and a small dashboard are there if you want them. If you only need people on the same Wi-Fi, --local gives a LAN URL with no tunnel.

Built with AI assistance (Claude), tested by me. MIT, no dependencies.

https://github.com/nikhilcherry/hoist

When testing, I've been using the default Flask server and it's worked fine. I tried testing it in a production environment on a VPS and I'm facing quite a few issues. My setup on the VPS is WSGI > Gunicorn (usually with 3 workers) > Nginx reverse proxy.

The first issue that doesn't occur in testing is that the CSRF just rejects any login attempts. I know this because commenting it out in the jinja templates and commenting it out in app.py solves the issue.

The second issue is that in production cookies aren't saved to the client side browser. I'm unsure if this is an issue with the code itself or maybe my Nginx config. I'll share the sites-available file for it as well.

The third issue is that SOMETIMES, despite credentials being correct (after using setup.py), the login gets rejected for incorrect credentials.

Here's my sites-available file for the site:

server {

listen 80;

server_name _;

location / {

proxy_pass http://127.0.0.1:8000/;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_set_header X-Forwarded-Proto $scheme;

proxy_set_header X-Forwarded-Host $host;

proxy_set_header X-Forwarded-Prefix /;

}

}

Also, if you find any other issues with the application I'd be so grateful if you could share them. Thank you!

i have a flask app with an ai chat feature and i am switching from json responses to sse streaming. basic generator works but it falls apart when i add auth, rate limiting, and error handling. everything ends up in one massive route handler.

a geekyants post on flask ai architectures suggested a dedicated service layer using the app factory pattern. has anyone here structured streaming ai endpoints cleanly across flask blueprints?

Hi everyone,

I have experience working with Angular, where we can create a complete project structure using a single command:

ng new my-project

Angular CLI automatically generates the necessary files, folders, configuration, and other boilerplate code.

Now, I'm learning Python and Flask for backend development, and I'm looking for a similar tool that can generate a complete Flask project structure automatically instead of creating files and folders manually.

I'm particularly interested in a tool that can generate a well-organized, production-ready project structure with features such as:

• Organized folders for routes, services, models, and configuration.

• Database integration using an ORM such as SQLAlchemy.

• Environment variable management using a .env file.

• Error handling and logging.

• Authentication and authorization, if supported.

• A structure that is easy to maintain and scale as the project grows.

My questions are:

1. Is there a recommended CLI tool or project generator for Flask that works similarly to Angular CLI?

2. Which third-party tool or project template is most commonly used in real-world projects?

3. Would you recommend Cookiecutter, a Flask-specific project generator, or another tool?

4. Is there a way to generate a project using a simple command like flask new my-project?

I'm looking for something reliable that follows good development practices and is suitable for building REST APIs and CRUD applications.

I'd appreciate your recommendations based on your real-world experience. Thanks!

Hi everyone,

I'm developing an existing Logistics & Inventory ERP for a wholesale business that uses its own trucks for deliveries. The application has been rebuilt as v5, and I'm trying to identify technical risks and resolve the remaining issues before using it in real business operations.

Technology stack

• Python / Flask

• SQLAlchemy / Alembic

• PostgreSQL (Neon)

• Render hosting

• GitHub Actions for scheduled background jobs

Areas where I need technical advice

1. Database and deployment reliability
How can I verify that database migrations, application redeployments and server restarts will not cause data loss? I also need a reliable backup and recovery process.

2. Order and inventory consistency
The system supports stock reservations, expiry-based batch selection (FEFO), order editing, cancellation and rescheduling. What are the most important concurrency and transaction tests to verify that stock cannot be oversold?

3. Weekly recurring orders
The staging deployment plan uses GitHub Actions for scheduled jobs because the current Render Free setup does not provide a built-in cron service. How should I ensure recurring orders are generated exactly once, even when a scheduled job is retried or runs twice?

4. Proof of delivery (POD)
The staging blueprint currently has photo storage disabled. What is a reliable, low-cost way to store delivery photos privately and ensure they remain available after redeployment?

5. Delivery routing
The current staging configuration uses heuristic route estimates and manual map-pin placement. I need advice on progressing towards reliable address handling, realistic travel-time estimates and route planning.

6. Multi-company security
The application uses PostgreSQL row-level security and role-based permissions. What tests should I run to verify that one company cannot access another company's customers, orders, inventory or delivery documents?

The documentation also reports different automated test counts in the README and changelog, so I need to verify the actual test suite and its passing status.

I'm not looking for a completely new application. I'm looking for practical technical explanations, recommended fixes and reproducible tests for an existing codebase.

My main question: Which areas would you investigate first, and what specific implementation patterns or tests would you recommend?

Thanks in advance!

Hi everyone! 👋

I'm a beginner learning backend development with Python. I've built a Personal Expense Tracker and converted it into a web application using Flask and SQLAlchemy.

The application allows users to add, view, update, and delete income and expense records and calculate their total income, expenses, and remaining balance.

Now, I want to improve this project by adding more practical features and following better backend development practices.

I'd love your suggestions on:

1. What real-world features should I add to this project?

2. What should I improve in terms of database design, code structure, and security?

3. What additional technologies should I learn to make this project more industry-ready?

4. What other practical Flask projects would be worth building to improve my backend development skills?

I'd appreciate any suggestions or constructive feedback. Thank you!

I'm developing a spreadsheet automation project capable of merging multiple spreadsheets into one and automatically performing calculations, among other things. One of the functionalities would be, for example, allowing someone to gather all the spreadsheets from those months into a single spreadsheet throughout an entire year, obtaining an overall result for the year. This could work based on week, day, month, or some other parameter. I have some doubts, but the project seems promising. I'm using the openpyxl library and, to create the website or application (I'm still undecided), I will use HTML, CSS, and Flask.

There are lots of Flask CRUD template apps on GitHub I'm sure. I've been wanting to make one myself for a while from scratch that's relatively basic and easy to modify. Most of the repos I've seen don't demonstrate all entity relationships like One To One, One to Many and Many To many.

https://github.com/TutorialDoctor/flask-template-app

The "admin" panel has custom CSS but I kept all the other views basic so you can add your own style. Still a WIP but it's mostly there

this has probably been asked many times, however all the posts in the past about anonymous websites seem to be people showing off their sites.

I've wanted to make an image board of sorts for a while, not because I'm a very avid user of them, mainly i want to because having my own community on my own website would be very cool, and i like to program. I know there is a lot of image board software out there but i want to build it from the ground up, in python too. I'm not trying to make a very complicated website, just image hosting, a few boards, and a moderation system, everything from that point shouldn't be too hard. Has anyone done this? is there any tutorials or docs for this? should i use Django?

i also want to note that a while ago i was trying to do this, however it feel through because i didn't really grasp programming, and I've tried a lot of stuff, but now i am a humble python skid

With .cgi frameworks, I can run an app and give it arguments on the command line, and then use python -mpdb to step through and see what is happening (and going wrong).

I have a flask app that is working, but not always working properly. So it does not crash, but it does not do what I expect.

I would like to be able to run: python3 -mpdb app.py

set a break point, and have the code stop at that breakpoint. I can set the breakpoint, but the code seems to ignore it, so I cannot single step through the program to see what is wrong. My app.py main() looks like:

if __name__ == "__main__":
      app.run(debug=True, use_reloader=False)

How can I debug my program using python3 -mpdb?

from flask import Response

@app.route("/routes", methods=["GET"])
def all_routes():
    route_text = ""
    for rule in app.url_map.iter_rules():
        methods = ",".join(sorted(rule.methods - {"HEAD", "OPTIONS"}))
        route_text += f"{rule.endpoint:<20} {methods:<15} {rule.rule}\n"
    return Response(route_text, mimetype="text/plain")

Anyone else do this? Is there a better way?

Hello everyone!

I recently built a Healthcare Chatbot as a Flask web application.

The project provides a conversational interface for general healthcare information. Users can enter health-related questions or symptoms and receive general informational guidance and wellness recommendations.

Technologies:

- Python

- Flask

- HTML5

- CSS3

- JavaScript

- Bootstrap

GitHub:

https://github.com/mshekinasamuel763-droid/healthcare-chatbot

This project is intended for educational and informational purposes and is not a replacement for professional medical advice or diagnosis.

I'd appreciate feedback on the implementation and suggestions for improvement.

I kept sending files to myself on WhatsApp because I had no better option. So I spent a few months building one properly.

FileDrop — open a site on two devices, use a 7-digit code or QR to transfer files or text, everything auto-deletes in 15 minutes.

No login. No account. No storage after the transfer.

GitHub: https://github.com/amaresh0812/FileDrop

The interesting bits from a Python/Flask perspective:

Storage split:

Redis stores only metadata per transfer — about 350 bytes of JSON regardless of file size. The actual file bytes go to disk under a UUID filename. This keeps Upstash token usage at 3-5 commands per full transfer cycle. Never storing file bytes in Redis was the most important architecture decision.

The cleanup problem:

Redis TTL auto-deletes the metadata key at 15 minutes. But that tells you nothing about the file sitting on disk. My fix: APScheduler runs a background job every 60 seconds that scans the uploads folder and deletes any file whose st_mtime is older than 900 seconds. It doesn't touch Redis at all — it uses the filesystem's own clock. This catches orphaned files even when Redis already deleted the key.

QR code:

Python's qrcode[pil] library, rendered into a BytesIO buffer in memory, converted to base64, included directly in the JSON response. JavaScript sets <img src="data:image/png;base64,...">. No CDN. No JS library. No extra HTTP request. About 1KB and 2ms of CPU time. Scanning opens /r/<code> which redirects files to /download/<code> or shows a burn-after-read text page.

Gunicorn workers:

--workers 1 --threads 4 in the Procfile. If you use multiple workers, APScheduler starts inside each process and your cleanup job runs 2-4 times in parallel. Single worker with threads avoids this without sacrificing concurrency.

Forms use AJAX:

Both the send and retrieve forms use fetch() with X-Requested-With: XMLHttpRequest. Flask returns JSON when it sees that header, HTML otherwise. Same route handles both — proper graceful degradation for no-JS browsers.

Stack:

main.py — Flask app · sheets.py — Google Sheets integration for contact/feedback forms via gspread · feedback.py — feedback handling

Python 3.11, Flask, Upstash Redis, APScheduler, qrcode[pil], Gunicorn, Railway

Live version is down temporarily (deployment issue I'm working through), but runs cleanly locally:

1. git clone https://github.com/amaresh0812/FileDrop

cd FileDrop

2.pip install -r requirements.txt

3. cp .env.example .env # fill in Upstash credentials

4. python main.py

README covers the full setup including environment variables and the architecture in detail.

Happy to discuss any of the decisions — particularly around the cleanup approach and the Redis metadata pattern. Genuinely interested if anyone has a cleaner solution to the orphaned files problem.

I'm working on a Claude Code plugin and wanted to see if its "read an existing repo and describe it" step holds up on a codebase I didn't write, so I pointed it at a fresh clone of Flask (d73fa1c) and went through its output line by line.

The part that's probably interesting here: in 3.2 twelve overridable methods (dispatch_request, full_dispatch_request, handle_exception and friends) now take ctx: AppContext as the first argument. Flask warns if your subclass still uses the old signature (src/flask/app.py around line 261). But which methods are affected and what counts as the new signature only lives in the source. The docs have two deprecation notes, and docs/shell.rst still shows RequestContext.push()/pop(). If your extension runs its tests with warnings as errors, that'll be a red CI run on upgrade day.

It also flagged the compatibility shim as a possible bug because it patches the Flask base class. Read the code, it isn't one: add_ctx only adds the context when it's missing, so new-style subclasses don't notice anything. Still worth saying that it sounded pretty sure of itself there.

All 21 file:line references it gave pointed at real lines. Nothing was sent to the Flask repo, no issue, no PR, this is just an outside look at one commit.

Write-up with all the sources, if anyone wants to dig: https://aspark.lottes.dev/en/blog/aspark-reads-flask/

Has anyone maintaining an extension already run into the 3.2 signature warnings?

After sending out a few applications, I realized how easy it is to lose track of where everything stands. So for my CS50x final project, I built Hubdex, a simple job application tracker.

It lets you save applications and organize them by status, including Wishlist, Applied, Interview, Offer, and Rejected. You can also add details like the company, position, salary, location, priority, notes, and application date. There’s a dashboard with basic statistics, along with search and filtering to make everything easier to manage.

I built it with Flask, Python, SQLite, JavaScript, HTML, and CSS. The project also includes user authentication, password hashing, and separate data for each user.

This project gave me a chance to put together a lot of what I learned in CS50x, especially working with databases, routes, forms, authentication, and CRUD functionality.

You can check it out here:

https://github.com/Akinmoldun/hubdex

https://bleach.readthedocs.io/en/latest/clean.html
I think I heard of nh3. Is it any good?

https://nh3.readthedocs.io/en/latest/

As stated early I could be wrong about bleach. Please correct me if I am.

As mentioned in the title good resource unte links share cheyandi

This code in flask/sqlalchemy:

sql = text("SELECT document.id from document left join document_person on document.id = document_person.document_id left join document_place on document.id = document_place.document_id WHERE person_id in (:people)")

query_vals = {}

query_vals['people'] = '5,7,12'

ids_q = db.session.execute(sql, query_vals).all()

ids = [id[0] for id in ids_q]

pprint(ids)

produces the output

[60, 44, 42]

but if I run this on the database directly, it does this:

mysql> SELECT document.id from document left join document_person on document.id = document_person.document_id

-> left join document_place on document.id = document_place.document_id WHERE person_id in (5,7,12) ;

+----+

| id |

+----+

| 30 |

| 42 |

| 44 |

| 49 |

| 60 |

+----+

5 rows in set (0.00 sec)

What is going on?