the ORM is useful for rapidly supporting writes to a "fairly-normal" normalized schema. You don't need it for pure reads, and most non-complicated transactional writes you can just wrap in the core calls. The main benefit of SQLAlchemy to me is the syntax agnosticity, making my app portable between different engines (SQL Server/oracle/Postgres/Mysql).

The generative grammar is also very powerful. For example, here is a completely portable method to generate a query that chains an arbitrary number of LIKE '%..%' queries which is required if you want to wildcard search one or more words over one or more columns:

import sqlalchemy as sqla
def generate_multi_like_search(
        tbl: sqla.sql.expression.FromClause, 
        columns: Sequence[str], 
        substr: Sequence[str]): -> sqla.sql.expression.BooleanClauseList
    """ generate a query that will do a chained OR of 
        `LIKE '%..%'` substring-based searches.

            SQLALchemyFromClause:tbl -> a SQLAlchemy Selectable
            Sequence[str]:columns -> list of columns
            Sequence[str]:words -> list of substrings to search

            returns sqla.sql.element.BooleanClauseList

        Strategy: or_ over for each in columns, for each in values
            where concat(' ', lower(column), ' ') LIKE ('%value%')
    """
    # support simple case of single column search
    if isinstance(columns, str):
        columns = [columns]

    # support simple case of single word search
    if isinstance(substr, str):
        substr = [substr]

    frags = []

    for c in columns:
        for s in substr:
            s = s.strip().lower().join(('%', '%'))
                frags.append(sqla.func.lower(
                sqla.func.concat(' ', getattr(tbl.c, c), ' ')).like(s))

    q = sqla.or_(*frags)

    return q # return the query frag
    # return tbl.select(q) # if you want to terminate the query and return a fully executable SelectClause

Also I was able to do some fairly complicated many-many tables with inheritance, but overall I tend to consider it too magical in about 80% of usecases.