Feature: a possibility to check whether Model matches Schema
I do not plan on implementing such an API, but the fundamentals are all there already.

You can use `database.get_tables()` and `database.get_columns()` and check for differences with `Model._meta.fields`. You can also use the higher-level `reflection` APIs.

* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_tables
* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_columns
* http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#reflection I put this little function together:

```python
from collections import namedtuple

from playhouse.reflection import Introspector


ValidationResult = namedtuple('ValidationResult', (
    'valid', 'table_exists', 'add_fields', 'remove_fields', 'change_fields'))


def validate_schema(model):
    db = model._meta.database
    table = model._meta.table_name
    if not db.table_exists(table):
        return ValidationResult(False, False, None, None, None)

    introspector = Introspector.from_database(db)
    db_model = introspector.generate_models(table_names=[table])[table]

    columns = set(model._meta.columns)
    db_columns = set(db_model._meta.columns)

    to_remove = [model._meta.columns[c] for c in columns - db_columns]
    to_add = [db_model._meta.columns[c] for c in db_columns - columns]
    to_change = []
    intersect = columns & db_columns  # Take intersection and remove matches.
    for column in intersect:
        field = model._meta.columns[column]
        db_field = db_model._meta.columns[column]
        if field.field_type != db_field.field_type:
            to_change.append((field, db_field))

    is_valid = not any((to_remove, to_add, to_change))
    return ValidationResult(is_valid, True, to_add, to_remove, to_change)
``` Pushed a new branch which contains the above commit (d6cbfd3), which includes this function as well as some basic unit tests. I don't plan on merging this, as it seems like a slippery slope of folks asking for more and more sophisticated difference detection. But it might be useful for those trying to implement something like you described? Wow, thanks for the really quick and detailed answer. 
I totally understand that this might be an overkill and out of scope of such library to implement every detail properly. 
The example code is helpful, thanks a lot!
I have some semi permanent data which I would be fine with losing when I need to update Schema. 
It would be nice to have a feature to check whether Model changed and recreate table if needed. I would imagine API and use case like this

```python
for model in model_list:
    if not db.validate_tables(model):
        db.drop_tables([model])
        db.create_tables([model])
```

I think this feature might be useful in early stages of many projects where it could be much simpler solution than running it manually or maintaining migration. Not sure how can this be implemented though.