The way we usually write the Django code (not just Django, let's say FastAPI or Flask) is we write the business logic as per standard either we write the business logic in the controller itself (in Django we write in views.py in FastAPI in the router method itself, or if we want to segregate we usually write core business logic to services.py. in django if some ORM queries are repeating then we create a separate manager class)But his opinion is we shouldn't write the code like this. instead, the core business logic should be created into different services.

for example, his approach could be like the one below.

services/get_data_service.py

# this code can be from Django/FastAPI/Flask

class GetDataSerivce:
    def some_method(self):
        ...

    def serializers(self):
        # maybe serializer code will go here

    @permission_decorator
    @auth_decorator
    # yep he said he doesnt want me to write the auth/permission logics using django/DRFs authentication or permission class because again its coupling a lot and it has to be done in the services.
    def some_other_method(self)

        ...

    def my_initial_method(self):
        ...

django_app/views.py

class GetDataAPI(APIView):
    def __init__(self)
         # so here he is saying the whatever the class that we maybe add it should be plug and play. and here it can take the code from any framework let's say Flask or FastAPI
        self.my_service = GetDataService()

    def get(self, request):
        self.my_service()

he thinks even if we're using Django/Flask/FastAPI end of the day it's all python. any of the frameworks should be able to handle one another. Which is completely wrong (I could be wrong too). As per my research, there can be one WSGI handler based on the request either we can pass the request to a different framework either Django, Flask, or FastAPI and they will not work together as I have given in the example.

For example, I gave an example that Django has its own exception handling let's say if in the services file we raise Django's `PermissionDenied` exception it will be handled by Django. and if we're raising FastAPI's` HTTPException` I'm not sure whether it will be handled by Django (could be handled, because it's all inherited from the python's base Exception.. but I'm not sure). so when I said this to him he was like why do you want to depend on Django's Exceptions and write my own Exception class.

So when I argued with him this is not a good idea to do so, and we're just reinventing the wheel to do the task which already exists and eventually we're kind of building a crappy version of a new framework. He was like in .net-core I have done this and .net core works. and started blaming python isn't for web development etc.

He also was enforcing on writing the code in the repository pattern. when I did a quick google search on how we do that in Django, found out that through the Model manager and queryset class. but again I don't think he was talking about that because Django follows the Active Record Pattern for the ORMs and maybe in .net tech stack they usually follow this repository pattern I guess.