Question: I am building an application that that will allow people to post information in different areas of a city (for about 10 cities). Do you guys know of any existing (normalized) databases/datasets that have this kind of information? Or would I need to create one from scratch? Any pointers suggestions very much appreciated!

Answer: 
Normalization in this case is somewhat problematic because the atomicity requirement specifies that a single attribute stores a single value of a given domain, and so things get pretty fuzzy here when looking at coordinate systems. There are a few options. Each of these is perfectly normalized.

**Separate Points Table**

In this approach you'd have a table that would be like (PostgreSQL notation):

```
 CREATE TABLE geo_points (
     id bigserial not null unique,
     x bigint,
     y bigint,
     z bigint,
     primary key (x, y, z)
 );

```

Records would go into this table, and comments would be joined on geo\_points.id.

**Point Type Approach**

Various databases have types for storing points. If we assume everything is at ground level and we do not need to track elevation, we can:

```
 CREATE TABLE tagged_location (
    id bigserial not null unique,
    user_id int references users(id),
    location point,
    comment text not null,
    primary key (user_id, location)
 );

```

With this approach, points might look like `'(134.22222, 94.4444)'` and different coordinate systems may be supported by the database management system. These may include flat coordinates, spherical coordinates, or the like. Choosing a coordinate system is very important because it impacts the units that come out in things like distance calculations. For example, if you use spherical coordinates, then distance is typically measured in degrees so if you want to convert to miles or km you have extra work to do.

**Numeric Array Approach**

You can represent a point as a numeric array. This is usually a workaround where there is no native point type. This meets 1NF because each array represents 2d or 3d coordinates for a single location. Ordinality matters, and so the array, taken as a whole, represents a single value (i.e. it is a tuple rather than a set or a bag). This is equivalent to the above approach with a point type except that typically you have to do your own distance calculations, and the point will look like `'{134.22222, 94.4444}'`

In the end with so many different approaches which are all perfectly normalized the question of database design is really constrained by your RDBMS and your use case. You probably won't find a ready-made design that perfectly suits your use case.
You could save it as two integers longitude and latitude (i think, if my geography is correct)