
JSON Resume – a JSON-based open source standard for resumes - krrishd
http://jsonresume.org/
======
esbranson
Europass CV (can be embedded in PDF files, easily exports to everything using
EU government web services):

[http://interop.europass.cedefop.europa.eu/](http://interop.europass.cedefop.europa.eu/)

HR-XML (also comes in a JSON variant, "HR-JSON"?):

[http://www.hr-xml.org/](http://www.hr-xml.org/)
[http://www.hropenstandards.org/](http://www.hropenstandards.org/)

There is also Microformat (hResume):

[http://microformats.org/wiki/hresume](http://microformats.org/wiki/hresume)

Europass is used by the European Union, HR-XML is used by the US government.
Microformats are probably used by many. This stuff is OLD news. We certainly
don't have a shortage of usable standards.

~~~
iaskwhy
Other people might be able to confirm it but I have never received an Europass
while working in London. I was told I should never send a cv made with the
Europass template as the relation between British people and European things
is not always the best. I understand this might be incorrect but it was enough
for me to avoid using it. Then I also spoke with some HR people from other
European countries who told me they didn't really like Europass so in the end
I created my own template using Bootstrap.

~~~
Argorak
Europass is also largely unknown. Politics aside, it is a good format and I
would much prefer to get standardized CVs like this, especially for the skill
assessment in languages.

The problem here is: some European countries use very particular formats for
their CVs. e.g. Germany has the "tabular CV", which expects all these things
to be organized by time and date, it even includes where and when you went to
Kindergarten. Europass doesn't fit many of those particularities (which is
kind of the point).

------
oh_sigh
I like the idea, because I deal with a lot of resumes and can't parse them
programmatically.

Some thoughts:

\- Eliminate first/last name distinction, and let people just put in their
full or legal/passport name. Names are very crazy across cultures, as in some
people don't have first or last names, so might as well just let them enter
free form text as their name.

\- Include a "Preferred name" field, also as freeform text. Some people like
to go by nicknames, or shortenings of their names, and it will help out.

\- Collapse location region and state into a single field.

\- If "websites" is a hash with only a single field, call it "website" and
make it a string.

~~~
thomasfromcdnjs
Awesome feedback, we already have an issue created for the firstName/lastName
dilemma.

Will create issues for your other feedback ->
[https://github.com/jsonresume/resume-
schema](https://github.com/jsonresume/resume-schema)

------
alexatkeplar
This is cool! We do a lot of work with JSON Schema at Snowplow. Here's a few
suggestions:

1\. Semantic versioning doesn't work for schemas. (What's a patch/bug fix for
a schema? It's meaningless.) Use SchemaVer instead -
[http://snowplowanalytics.com/blog/2014/05/13/introducing-
sch...](http://snowplowanalytics.com/blog/2014/05/13/introducing-schemaver-
for-semantic-versioning-of-schemas/)

2\. Make your schema self-describing so that a given resume instance is
associated with its schema version
[http://snowplowanalytics.com/blog/2014/05/15/introducing-
sel...](http://snowplowanalytics.com/blog/2014/05/15/introducing-self-
describing-jsons/)

3\. Publish your JSON Schemas to Iglu Central, the first schema registry for
JSON Schema - [https://github.com/snowplow/iglu-
central](https://github.com/snowplow/iglu-central)

~~~
thomasfromcdnjs
Adding your issues to the tracker and also thanks for the link to Iglu
central!

~~~
alexatkeplar
Nice one! If I can help in any way, just let me know. Iglu and Iglu Central
are very young but we're v excited about them.

~~~
thomasfromcdnjs
I imagine you have seen [http://schemastore.org/](http://schemastore.org/)

~~~
alexatkeplar
Cool - hadn't seen that. I really like the catalog concept - we didn't have
that in Iglu previously, have added a ticket for it. I'll reach out to Mads -
thanks for the link!

------
ARussell
I disagree with so many people in this discussion recommending XML without
much reason. The best reason I've ever seen to pick XML over JSON is mixing
text and elements, and that doesn't seem like an issue, here.

As for feedback on the schema itself, I'd probably like to see some more
detail allowed for the courses under education. I remember after graduating,
there really wasn't anything more substantial that I could put other than
details about my courses. Using the example on your page, I think "HS1302" and
"Introduction to American History" could possibly be separate fields, and I
think there should be an additional details/description/highlights field.

Also, I am a consultant, and I like to list a projects section. Each project
could have a name, a client, an employer (the consulting company), a date
range, and details.

~~~
thomasfromcdnjs
Thanks! Will copy your feedback where appropriate to the issue tracker

------
macspoofing
If only there was an extensible markup language you could employ to create a
resume standard.

//

Seriously, JSON really sucks at markup (it also kinda sucks as data
interchange as well, but let's not worry about that here). This 'standard' is
so hand-wavy. Every property is a 'string', so why are you even bothering
putting it in? Right, not really 'strings' because a bunch of fields have a
JavaScript (so we're not really sticking JSON here, are we!) comments to
describe it. Presumably order of object properties matters, or maybe it
doesn't, or maybe it matters for some (e.g. root object / address) and not for
others (eg. phone numbers). Date format? Who needs that! Which fields are
optional? All of them? Some of them? None of them? I like the 'hobby' field.
Complete waste of space on a real resume and a complete waste of space here as
well (hah: hobby name and hobby keyword). Urgh.

It's a mess. A total mess.

~~~
thomasfromcdnjs
You are right, it is a mess, we are working on the specification at the moment
and deciding on correct data types and semantics. If you think with a bit of
love it can be made into a usable standard please come help us out at
[https://github.com/jsonresume/resume-
schema/issues](https://github.com/jsonresume/resume-schema/issues)

~~~
macspoofing
JSON is the problem, so this will continue to be a mess. Especially if you
have hopes for this to be used by many many people and especially if you hope
this can be ingested by many many different systems (e.g. every resume
submission server for every company). You need to formalize the structure, so
you need some sort of a formal schema. You may pretend you don't need one, but
you kinda have one right now. The schema you have right now is your example
structure and JavaScript comments.

~~~
tracker1
You do realize that there is a JSON Schema specification, not to mention that
JSON more naturally matches a program's object structure for serialization and
deserialization. Generally speaking XML is more flexible than any object
representation should be. Objects tend to have properties, and those
properties may be a given type. But XML may define some properties as
attributes, and others as a single /nested child element and others as 1+
child elements, or a child element with 1+ child elements. JSON is a natural,
easy to understand and comprehend map without extra content that really isn't
needed. JSON maps neatly to several object streaming systems, XML does not.

I'm sorry, but XML isn't some panacea of describing or encoding document
structures. It's generally a collection of fragile verbose and overly
complicated tools in a few given platforms to satisfy people that think
enterprise programming means implementing every pattern that loosely fits
their situation instead of clean, simple, elegant solutions that hide
complexity where needed instead of creating more.

JSON + JSON-Schema is no more of a mess than XML + XML Schemas. And generally
far more forgiving in any modern programing environment for client/server use.

~~~
hyp0

      > JSON + JSON-Schema is no more of a mess than XML + XML Schemas.
    

For this reason, many developers resist JSON-Schema. _We already have one
mess, if we need it - let 's keep JSON clean! That's why we like it._ A
concrete example of keeping JSON clean was the removal of comments from the
JSON spec to stop people using them as directives. If they had stayed, and
JSON became complex and ugly and messy, would its popularity have continued?

However... the increasing prevalence of complex JSON formats may eventually
make _some form of_ JSON schema necessary.

------
dheera
Nice. Although I'm not too sure what the social implications of this would be.
As it is already I think employers do too much parsing of resumes rather than
looking at them with human eyes. PDF resumes are awesome in that you get a
blank sheet of paper to do whatever you want with to impress the employer.

There's a lot of reading between the lines that can be done in an resume. Even
the fonts say something about the person. If the person is claiming to be a UI
designer and their resume has poorly chosen fonts and bad kerning, I'd toss
it. If they claim to be a physics researcher and the resume is written in
Word, I'd toss it too. With a JSON resume you don't get any of this
information.

Also, it's not entirely clear how extensible this "standard" is. Resumes take
multiple forms. A computer scientist might want to list a few open source
projects. A photographer might want to embed a sample or two of their work.

~~~
keehun
Yeah, I was going to say that this project is awesome, and I like the web
themes, but the PDF export needs a lot of work. I think that will be the
hardest aspect to achieve. Maybe some LaTeX resume themes can be borrowed
from. There are some very nice ones in LaTeX.

~~~
dheera
Maybe. As someone who likes to be creative I'd still never use someone else's
template though. Even the font I use on my resume I did some editing on
because I didn't like the way a couple of the glyphs looked.

~~~
xienze
I think that gets to the heart of why a standard metadata-to-pretty-resume
solution has never really taken off. The people who really care about it don't
even bother trying to make a one-size-fits-all solution, since it's such a
customized and personal undertaking. Glad to hear I'm not the only person
who's spent countless hours tweaking my resume to the nth degree.

------
bphogan
I think this is a great idea. I love the idea of a universal data format for
resumes.

However, I'm not at all convinced that JSON is the way to do it. I think the
way to do it is with XML and XSLT, although I already can hear the cries of
"But XML is yucky and XSLT is hard." But by using JSON, we lose some semantic
markup and end up having to parse it to create some semantic markup.

Still, I hope this, or something like it, takes off. This just needs a web-
based GUI tool to publish a resume so that non-geeks can make it happen.

~~~
thomasfromcdnjs
It was a very hard decision to make and starting such a movement is
unfortunately from my viewpoint much more than making rational choices about
the technologies. We wanted to have a low barrier to entry and also take
advantage of the large ecosystem of libraries. At the moment the majority of
web technologies are using JSON so we believe that to get this standard off
the ground we will need to go with the grain.

LinkedIn actually exports into a Microformat called hResume which has been
around for a long time but has evidently not been able to amass a large
developer community. This was another reason we decided to not start with XML.

~~~
xienze
> LinkedIn actually exports into a Microformat called hResume which has been
> around for a long time but has evidently not been able to amass a large
> developer community. This was another reason we decided to not start with
> XML.

So, not trying to be rude here, but have you wondered why it is that an XML
resume format hasn't taken off? Other than it being based on icky XML? I mean
XML+XSLT has been around for a loooong time and can more than handle exactly
what this format sets out to do, and yet a standard XML resume format hasn't
taken off.

~~~
mindcrime
There's nothing particularly "icky" about XML. That's just a silly hipster
meme. XML is just a tool, it makes sense in some places, less so in others.
Same deal for JSON.

 _I mean XML+XSLT has been around for a loooong time and can more than handle
exactly what this format sets out to do, and yet a standard XML resume format
hasn 't taken off._

It's just as likely that the answer is "a standard resume format hasn't taken
off" where the serialization format is irrelevant. Maybe not enough people are
interested in working with documents and knowledge at that deeper,
semantically meaningful level. Maybe sending resumes as PDF or MS Word or ODT
and using simple keyword extraction has been "good enough" that nobody has
felt the pull to use a better system?

What I mean is, it's entirely possible that this will fail to gain adoption
for the exact same reason that the XML based one(s) did, and that the
difference between JSON and XML is actually irrelevant. This is, of course,
just speculation on my part. In any case, I _hope_ this (or something like it)
gains traction, since I'm a strong proponent of publishing semantically
meaningful content, whether it's in RDF/XML, JSON-LD, SGML, DAML+OIL, YAML,
Texinfo, Markdown, Hytime or hieroglyphics chiseled into stone tablets. :-)

~~~
e12e
Agreed. There is one difference with json (and yaml) though: it truly is more
human writable (and readable), and by extension provides nicer diffs. I'd be
much more happy to maintain my resume in json than in XML, even if I might be
more happy _exchanging_ / _submitting_ resumes with (one of) the existing XML
standards.

But all that's needed is a script that eats XML resumes and outputs json
resumes, and vice versa.

Just like I'd rather write markdown and read (rendered) html+css.

That said, on the subject of XML not being "icky": one resource for having fun
with XML: "Program Generators with XML and Java" by J. Craig Cleaveland
(Prentice-Hall, 2001):

[http://craigc.com/pg/](http://craigc.com/pg/)

~~~
e12e
Hm, looks like there might be bit too many dependencies here for my taste:

    
    
        npm install resume-cli
        du -hs node_modules
        103M node_modules
    

All this, and it doesn't provide line numbers when reporting errors due to an
extra comma in the json file? Nor does it (yet) have LaTeX output...

Still, can't complain, 5 minutes and I have a resume draft that doesn't look
half bad in html, and is presumably entirely reasonable to customize (not to
mention it's all inn a json-file anyway, so one could just use what's in ones
actual resume, and shove the json through pretty much any scripting language
w/templates and generate something reasonable).

~~~
thomasfromcdnjs
Sorry about the large dependency size, we were mainly rapidly prototyping and
didn't expect so much usage. That size will drastically be reduced and we hope
to have better error reporting.

Currently have 60 fresh issues on Github for the schema so after we digest
those we will be improving the CLI once again.

------
grillp
I know it's a little heavy weight, but there is already an open standard
around this:
[http://www.hropenstandards.org/](http://www.hropenstandards.org/)

They have a HR-JSON and HR-XML schema for HR docs..

Reinventing?

~~~
simonw
It appears you have to register for an account on that site AND wait for your
membership to be approved before you can even download a standard or view
documentation.

If that standard is important and well designed, it should be trivial to write
a converter from JSON Resume.

As Douglas Crockford once said (I believe in reference to XMLRPC) the great
thing about reinventing the wheel is that you might get a round one.

~~~
indymike
You can download without being a member. There is a Download Standards page
that anyone can download from. It's pretty straightforward.

(on the HR Open Standards Board of Directors)

------
tommorris
Just use HTML + hResume. hResume is based on vCard and thus the name and
address fields are actually sensible rather than hacked together without
considering edge cases. It lets you use prefixes and suffixes (like Dr, Prof,
Rev, PhD, MD, JD etc.). It lets you format text using HTML tags. You can link
to it.

If you want JSON, you can export it from the hResume using a parser.

Unlike JSON (or XML), non-programmers can read HTML in a crazy new piece of
technology called a web browser without having to run it through any
transformation tool. Want PDF to send to a company? There are a few WebKit PDF
renderers available.

Want to style it? CSS.

Want nice fonts? WebFonts.

It's a web page. Crazy idea.

Classic version:
[http://www.microformats.org/wiki/hResume](http://www.microformats.org/wiki/hResume)

New version:
[http://www.microformats.org/wiki/h-resume](http://www.microformats.org/wiki/h-resume)

------
thomasfromcdnjs
Hey guys, we weren't actually ready for a lot of eyes to see this project. We
were hoping to keep it small and get some feedback on important decisions
about the project's trajectory.

The plan is to create a standard that developers worldwide are comfortable
enough with to build upon.

To give the standard some traction, we have built tools to export to other
formats such as pdf, txt and doc.

We also thought it would be cool and useful to have an NPM like system for
resumes. So we built a CLI heavily inspired by NPM, to init and publish your
resume to the jsonresume.org registry.

The themes right now are in bad shape, and we are looking for designers who
would love to jump in during the early stages. We are thinking of building a
theming version manager on top of NPM to take advantage of
versions/distribution and also allow theme developers to implement their
theming systems however they like (erb, mustache, md etc).

All the code is open source and available at ->
[http://github.com/jsonresume](http://github.com/jsonresume)

Theme developers should be looking at the resumeToHTML repo ->
[http://github.com/jsonresume/resumeToHTML](http://github.com/jsonresume/resumeToHTML)

People with comments about the standard semantics and structure are encouraged
to post their ideas to Github issues. -> [http://github.com/jsonresume/resume-
schema](http://github.com/jsonresume/resume-schema) We also want to formalize
the standard a lot more over the coming weeks.

If the project can be pulled off professionally and driven by the community,
we believe that working with resumes will be fun!

Edit: Here are some of the reasons why I personally think JSON resumes will
improve HR.

(trying to figure out bullet points)

\- Better searching and filtering than PDF/doc. Making recruiting a tad
easier.

\- Applying themes will be a lot easier.

\- Applying for jobs will be easier. Instead of filling out complex forms over
and over again services might start allowing you to auto-fill with your JSON
resume.

\- There are many services that ask for your career history such as LinkedIn,
Angel.co etc. These could be autopopulated or synced with your master copy.

\- You can update your resume programatically so Github projects can be
inserted and any other online certificates that you might want automatically
added to your resume like Mozilla Open Badges ->
[http://openbadges.org/](http://openbadges.org/)

\- The comment section suggests that lots of innovation could arise from it.

\----------

Make sure you try the CLI! _sudo npm install -g resume-cli_

~~~
pserwylo
I would just like to say that I think that this is a great idea(despite
agreeing with others here that XML + XSLT would seem like a more logical
choice). I hope it gets some traction in the long run.

I've posted an issue on github [0][1] mentioning that "firstName" and
"lastName" is probably not a good representation of names. I don't actually
know what the solution is, but this article [2] gives some great reasons why
we tend to make incorrect assumptions about peoples names, which have the
possibility of excluding some people form our tools based on their name alone.

[0] - [https://github.com/jsonresume/resume-
schema/issues/4](https://github.com/jsonresume/resume-schema/issues/4) [1] -
It seemed like an appropriate place to comment. Please let me know if there is
somewhere else you'd prefer such comments. [2] -
[http://www.kalzumeus.com/2010/06/17/falsehoods-
programmers-b...](http://www.kalzumeus.com/2010/06/17/falsehoods-programmers-
believe-about-names/)

~~~
Uehreka
Regarding names, I've heard of two solutions that cover enough edge cases to
be suitable:

1\. Asking for "Given Name" and "Surname" clears up most issues with cultures
like Korea (where surname comes first).

2\. Simply have a "Name" field. Accept any Unicode characters. Hope for the
best.

If someone has a name that cannot be represented in written characters or
cannot be rendered in Unicode (which would be amazing, since Unicode covers
ancient dead languages and fictional languages like Klingon) they probably
have more pressing issues than trying to serialize their resume.

~~~
pbiggar
Mostly, people ask for firstname and lastname because they want to call you by
one of them. you can avoid this problems by having a "Full name" and a "what
do we call you": my full name is "Paul Biggar" but you should call me "Paul".

This solves some of the falsehoods programmers believe about names:
[http://www.kalzumeus.com/2010/06/17/falsehoods-
programmers-b...](http://www.kalzumeus.com/2010/06/17/falsehoods-programmers-
believe-about-names/)

~~~
wink
Still not the silver bullet.

In Germany it's not really common to call people by their first name (IT is an
exception), but I would hardly put "Mr. Lastname" into "what do we call you".
It all depends on the context, even in the limited scope of a resume.

~~~
couchand
If they're just looking for something to say on the other end of the phone
when you answer, isn't "Mr. Lastname" the appropriate thing to enter in that
box?

~~~
levosmetalo
No, it's not, because calling someones phone is also culturally dependent.
Because in Germany, when you are calling someone, it is expected that person
picking up the call will speak up first and introduce themself. Something
like: "Herr Mustermann, hallo!".

You see, if you are calling person from Germany, knowing how to address him is
not enough, you shall still know how to make a call. If you don't know that,
you'll be rude anyways, and if you know that, you'll also know a proper way of
addressing persons in different cultures.

------
mindcrime
I have to admit, I'm having some trouble seeing the value in this... JSON does
not strike me as a great format for a document of this nature, although it's
certainly _possible_. Offhand, I'd think XML is a more natural fit for this.

Anyway, more to the point, there has been some existing work done on
developing standards for representing resumes. I would _highly_ , _highly_
encourage you guys to look at this and consider making whatever you do
compatible with the existing work as much as possible. Consider ResumeRDF[1]
for example. Maybe consider doing JSON-LD and using the FOAF and ResumeRDF
vocabularies?

[1]: [http://rdfs.org/resume-rdf/](http://rdfs.org/resume-rdf/)

~~~
DanBC
I just had a look at ResumeRDF.

    
    
        Class: cv:Person
    
        Person - CV subclass of WordNet person
    
        in-range-of:	cv:aboutPerson cv:referenceBy
        in-domain-of:	cv:gender cv:birthPlace cv:hasCitizenship cv:hasNationality cv:maritalStatus cv:noOfChildren cv:hasDriversLicense
    
        [back to top]
    

It's probably a bad idea to encourage people to list protected characteristics
on a CV / resume. Employers (except vary rare exceptions) can't use this
information so there's no point including it.

~~~
mindcrime
That's an interesting point. And to be honest, I'm not sure what the rationale
was for including those terms (I wasn't involved with defining ResumeRDF or
anything).

I'm _guessing_ it happened because they "borrowed" a generic notion of "person
attributes" from some other, less specific, source, and didn't really consider
the legal implications you mention.

I guess it's an open question whether or not there's any actual valid scenario
where somebody would want to put that stuff. It seems unlikely to me, but
maybe in other countries or something? Hmmm... dunno.

~~~
thomas11
In Europe, at least in Germany and Switzerland, it's normal and expected to
state your birthday and place of birth. You also include a passport-sized
photo of yourself, usually in the top right corner.

See for example this guide to resume writing by a German university [pdf]:
[https://www.uni-
muenster.de/imperia/md/content/math_nat_faku...](https://www.uni-
muenster.de/imperia/md/content/math_nat_fakultaet/formularefb_11/lebenslauf.pdf)

~~~
mindcrime
Aah, OK. That's pretty interesting, actually. Here in the US it's practically
verboten to ask anything about nationality, religion, ethnicity, etc., and
conversely pretty much nobody ever volunteers that stuff either.

------
TeeWEE
This is exactly where XML is the only right choice. JSON is much simpler than
XML, thats why lots of people like it. However for documents XML markup is
more appropriate. The reasons:

\- Allows extensibility with other xml standards (such as SVG and MathML in
your resume, which might makes sense) \- Allows linking to other stuff with
XLink \- Allows styling it with lots of xml styling technologies. \- Better
versioning support

JSON is not bad however, so if you just want to have simple plaint text cv's,
json is good enough. I do agree that with XML comes bloatness, complexity, and
more crap. However from a pure technical point of view, its a better option
for doing resumes.

~~~
stevekemp
I have a resume I've been working with for a few years now, and it was built
using:

[http://xmlresume.sourceforge.net/](http://xmlresume.sourceforge.net/)

That project seems dead now, and recent updates to my systems have resulted in
me being able to build HTMLTXT but not PDF.

In the future, when looking for a job, I'll be looking at JSON instead. It
might not be the best tool, but it seems to be what several _live_ and active
projects are using.

------
mitchellh
I looked over the website briefly, and I couldn't find an answer to this
question so I'm going to ask here. I am not asking this tongue-in-cheek, these
are serious questions:

* By "open source standard," what do they mean? I don't see any evidence they're on an RFC track, so this would be "standard" in what way?

* Why? I've never needed a resume in JSON format, but that is anecdotal. They don't really say why they're pursuing this on the site, except why they chose JSON.

Good luck, either way! Making something isn't easy, so I applaud any effort to
do anything.

~~~
gkoberger
Assuming this takes off and everyone uses it (you be the judge of those odds),
I can see a standard format being really useful for both employers and job
board websites.

Let's say you had a bank of resumes -- you could easily find all resumes that
know Java and have had at least 2 jobs and an active GitHub repo, and
automatically send out a request to their references.

Currently, you have to read an unformatted PDF and extract the info manually
-- it's not the end of the world, but it gets tedious if you're dealing with
lots of resumes.

~~~
hmsimha
It would be really useful for the people making the resume also. Right now the
current mainstream advice is to use Microsoft Word for creation and editing
and then (typically) to submit as PDF. Both of those document standards are
proprietary and opaque. If you two computers that don't have the same
operating system, you're probably SOL for tweaking your resumes across
computers as well.

------
BinaryIdiot
This is a neat idea but this schema is a bit...specific in areas. Much like
XML schemas of past the great thing about the JSON interchange format is that
it's insanely flexible and anything goes (essentially).

I feel like it would be a much better way of handling resume type data if it
was self describing rather than using a very specific schema that ties you
into a data structure that may not make sense in many cases. In that case you
could simply look for different types of data to display versus a very
specific format that won't hold up to every use case.

------
Qantourisc
My main concern and same question for my own resume: what skill strings should
be used ? Server Administrator or System Engineer ? Programmer or C++ ? etc...
That's what will be one of the more challenging things to solve. Otherwise you
might have a resume-format, but no way to reliably use that data as a
computer, or that out of scope ?

~~~
icebraining
This is why the Semantic Web has _links_ (URIs), so that we point to
unequivocal concepts. They would do much better to use JSON-LD instead of dumb
strings for these CVs.

------
jaltekruse
While I don't jump for opportunities to fiddle with a word processor to make a
document like a resume look good, I am curious if this is partially driven by
an effort to populate databases with information. While I have been
unimpressed by efforts to do this by scanning a doc or pdf file, I am afraid
of the possible implications for encouraging poor recruiting techniques.
Having a searchable database can be nice, but there are so many other layers
to finding good talent.

------
crdoconnor
If you want this to take off, you really need to provide a mechanism for
exporting it to a wide variety of large resume handlers (monster, various
large employers, etc.) and importing (e.g. from linkedin).

Otherwise you have the xkcd problem:
[http://xkcd.com/927/](http://xkcd.com/927/)

It's boring and tedious work, and the number of edge cases will multiply
geometrically, but it's likely the only kind of thing that would make this
take off.

P.S. Why not YAML?

~~~
thomasfromcdnjs
We were nearly going to do a brand change because JSON and YAML are
interchangeable and it doesn't really make any sense to just promote JSON in
this case. I also love YAML, the problem was writing specification's seems a
lot more mature when you follow the json-schema.org project. So I thought why
not write it initially in JSON with the json-schema project as a basis and
then just supply the tools for people who prefer YAML.

~~~
crdoconnor
Ugh, json schema is horrible. Have you used orderly? It's far less verbose,
more readable and it compiles to json schema.

I agree that making it interchangeable is best overall (especially since there
is a 1:1 convertibility between the two languages).

Perhaps the brand should actually reflect this instead. JSON is preferable in
a data interchange scenario, but for keeping or displaying a human readable
version, YAML is better.

As before, though, it's not YAML/JSON - it's the richness of the import/export
filters that will make this idea float or die. Nobody much is going to want
this so that they can publish their resume on jsonresume.org. People will want
to use it so they can efficiently and easily import their linkedin resume and
upload it to [insert fortune 500] company's custom HR portal / top 7 job
sites.

------
yellowapple
Looks nice (and this is coming from someone who's pretty weary of the "hey
let's put the whole world on npm" attitude). Seems to be a pretty decently-
thought-out structure; after converting to YAML (my preference), it's pretty
straightforward to work with.

Some comments:

\- I found it a bit odd that 'resume init' only prompted for firstName and
personal email; a more complete wizard would be useful. I suppose it wouldn't
be hard to create a third-party "JSON resume generator" app with a nice
friendly pretty interface for this (it _is_ just JSON, after all).

\- As mentioned in other comments, the "firstName" and "lastName" fields make
excessive assumptions about the user's native/preferred naming convention.

\- The schema only provides for a "blog" element in the "websites" array. More
options would be appreciated, since not every personal website is a blog.
Alternately (if the intent is really for only one website entry), providing a
scalar/string "website" element would be more to-the-point.

\- As someone who prefers YAML (it looks so much nicer), built-in support for
YAML<->JSON conversion would be awesome for me (i.e. be able to export to /
import from YAML). For now I'm fine with using yaml2json/json2yaml, but such
import/export functionality would be awesome. Perhaps a command-line switch
for exporting (i.e. "resume init --yaml")? Alternately...

\- On the above note, would it be possible to make "resume init" output to
STDOUT instead of directly to a file? That way, it would be simple to run
"resume init | json2yaml > resume.yaml" (for example).

~~~
thomasfromcdnjs
Thank you! We are inundated with work right now so I can't reply fully but I
will probably end up using the YAML version myself so I've created an issue to
implement YAML into the CLI -> [https://github.com/jsonresume/resume-
cli/issues/20](https://github.com/jsonresume/resume-cli/issues/20)

Will add your other feedback to the issue tracker soon.

------
Mister_Snuggles
Some things that I think would be useful to add to the schema, in no
particular order:

* It's common for resumes to include a full address, so elements supporting that could be added to the location. There should probably be a way to strip this out before publishing it to a public place though.

* I'd like to see a section for volunteer activities. I do some volunteering which, while not related to my day job, is worth highlighting.

* The references section would usually include contact information for a potential employer. Generally this would be a separate page that would be given during an interview. My main resume says "References available upon request" and I have a separate document with my references in it.

The biggest win, in my mind, is that the schema captures the knowledge of what
belongs on a resume. Being able to take that single source and produce
multiple versions (e.g., the public one, the private one with full details, a
list of references, etc), not to mention everything else that comes with a
standard schema, is a huge bonus.

~~~
thomasfromcdnjs
Great ideas! I will start add them as issues to the schema repo ->
[https://github.com/jsonresume/resume-
schema](https://github.com/jsonresume/resume-schema)

Your meta-layer idea is great too, at the moment we only have password
protected resumes.

We are actually building an encryption converter, so you can encrypt your
resume with a passphrase, I imagine these public,private etc versions could be
controlled by encryption.

------
awalton
In other words, Microformats have arrived in the Web 3.0 sphere. (hResume
never really caught on either, despite LinkedIn supporting it.)

------
konstruktor
As someone from a country with very different resumes, my suggestion would be
to be more explicit about this being about US style resumes. If you want
decent rendering, you need to focus on one style anyway (too much variation),
so just be open about your scope and optimise the hell out of it, saving you a
lot of i18n worries (names, addresses etc.).

------
prat0318
I have earlier written a similar json resume conversion gem -
[http://prat0318.github.io/json_resume](http://prat0318.github.io/json_resume)
I am currently working on i18n and a real time conversion web app. I would
love to have something standardized and i hope it gets an active community.

------
peteretep
I write software that interacts with CVs/Resumes for a living. Why would I use
this over something based on HR-XML?

------
emiller829
This reminds me a bit of an idea I messed around with a bit last year:
[http://erniemiller.org/me.json](http://erniemiller.org/me.json)

I posted about it then ([http://erniemiller.org/2013/06/19/my-happiness-
formula-me-js...](http://erniemiller.org/2013/06/19/my-happiness-formula-me-
json/), but the thought at the time had been that it would be nice if
prospective employees published something along the lines of things that
contributed to their contentment with work.

This was eventually intended to be presented sans ratings in a little browser
plugin, for recruiters and the like to score themselves honestly against the
criteria, and a little bit of math would yield a compatibility rating on a
click.

It wouldn't take long until such a thing evolved into a more full-featured
resume such as this. I like the idea.

------
codgercoder
Doesn't it ever dawn on anyone that employers insist on detailed, accurate
information about applicants, in standardized forms, while the information
available about employers is a mess? There's no standard, there's no
requirement, and they can mislead in quite creative ways. Hardly seems fair.

~~~
ubershmekel
[http://www.glassdoor.com/](http://www.glassdoor.com/) is a good start.

------
hunvreus
I've been thinking about exporting my resume to a similar format (hResume or
equivalent) for a while; I find LinkedIn of little value for me.

I can imagine that for certain people it offers opportunities to "network",
but in my case it is more an invitation for random people to spam me than a
tool to connect.

Beyond the resume, I am wondering if it would be possible to build some kind
of decentralized professional network, with resumes as nodes and
professional/academic relationships in between, maybe even a vetting system
(LinkedIn recommendations are not only time consuming but also worthless
IMHO).

------
krapp
Random Project Idea - use this as part of an API which scrapes multiple sites
(like Linkedin, Github, Monster, what have you) and builds a single, canonical
resume from the various sources using this standard.

I don't know that the themes, necessarily, are that useful (I don't like the
idea of implicitly connecting presentation with JSON like that - i'll make my
own themes thank you) but I do like the idea of a common transport format for
resumes.

~~~
thomasfromcdnjs
That sounds very ideal, I'd love to automatically insert my online
achievements into my resume.

------
zobzu
I find less-structured formats easier to read for this kind of data. Such as
wiki-style markup (markdown, RST, etc.)

~~~
cm127
Same here. My resume is a text file in markdown. Bullets, titles and subtitles
are all you need for a simple, easy to read resume.

------
baconchunks
Another possible section to add: speaking engagements (or public appearances
or perhaps the more generic "public events").

You have publications, but that implies written material is produced. And
should publications have a place for co-authors? It seems wrong to not
acknowledge them.

~~~
thomasfromcdnjs
Just added this as an issue yesterday ->
[https://github.com/jsonresume/resume-
schema/issues/3](https://github.com/jsonresume/resume-schema/issues/3)

Thanks!

------
troydm
I've been more partial to schema.org's JSON-LD patterns. I'm curious what key
differences made you opt for one over the other.

I could see this as a natural expansion of
[http://schema.org/Person](http://schema.org/Person)

------
jaseemabid
I'm happy that there is no 'Career Objective' section. This website[1] is down
now but I think the name convey the idea.

1\.
[http://whatthefuckismycareerobjective.com/](http://whatthefuckismycareerobjective.com/)

------
ff7c11
[http://microformats.org/wiki/h-resume](http://microformats.org/wiki/h-resume)
looks good as you can choose how you want to display the data as well as
allowing parsing to JSON if you want

------
michaelq
Would it make sense to mimic attributes present in LinkedIn's JSON structure?
Most people already have a LinkedIn profile, and it would be easy to make a
tool that exports LinkedIn profiles into you new open standard.

~~~
thomasfromcdnjs
You are correct, LinkedIn uses a Microformat called hResume, in our templates,
we will export to HTML with built in support for the Microformat.

We also want to build a feature into the command line tool that lets users
sync their resume.json to LinkedIn.

------
sktrdie
There's already a W3C Ontology for Resumes:
[http://www.w3.org/wiki/ResumeRDFOntology](http://www.w3.org/wiki/ResumeRDFOntology)

All you have to do is use the terms with JSON-LD.

------
mb2100
I just wrote my resume in markdown and export it to txt/html/doc/PDF with
Pandoc: [http://johnmacfarlane.net/pandoc](http://johnmacfarlane.net/pandoc)

------
ironlady
Very cool! I started something like this with a WordPress implementation a few
years ago and never bothered to complete it, so cool to see somebody else with
a similar idea and actually finished it!

------
ladon86
In the education section, I'd like to see an option for GPA or degree class.
Be aware that some countries do not provide a GPA (for example, the UK has
these classes: 1st, 2:1, 2:2, 3rd).

~~~
thomasfromcdnjs
Added as issue to the schema repo, thanks!

------
est
Need more formal ontological definition of the "skills" field, E.g. If you
type "Django" the system should infer that you have fair amount of Python
skills already.

------
59nadir
Is it just me, or does it feel just a tiny bit ridiculous to see Twitter
proposed as being on a CV? GitHub, sure, but Twitter? Shouldn't we just add
our WoW accounts and maybe our old ICQ numbers too?

For people interested in standardized CV, by the way:
[http://europass.cedefop.europa.eu/en/documents/curriculum-
vi...](http://europass.cedefop.europa.eu/en/documents/curriculum-vitae)

This site details some stuff about working with Europass:
[http://interop.europass.cedefop.europa.eu/](http://interop.europass.cedefop.europa.eu/)

I'm surprised they didn't go for interoperability with what's already out
there.

------
pacmanche
Created a JSON Resume LinkedIn exporter [https://github.com/mblarsen/resume-
linkedin](https://github.com/mblarsen/resume-linkedin)

------
pests
I could see validators and other resume-specific checks coming about because
of this.

Checking that dates are logical, spell checks, checking for dead links,
showing employment gaps and so on.

~~~
thomasfromcdnjs
Great idea! Added as an issue to the resume-schema repo

------
onassar
Awesome idea. I could imagine a marketplace for resume themes that is based on
this. Would be easy to switch between different designs to see consistent
details.

Well done.

~~~
anko
Isn't the look of your resume one of your competitive advantages as job-
seeker?

Sorry I really don't understand the use-case. Having an API is good for
styling (as you say), or doing some soft of programmatic transformation to
data. I am having trouble understanding the need to do either for a resume.

Maybe it would help as metadata for a search engine, but in that case I think
a plain text search would be just as effective?

I think json schema is a really nice thing to have and I'd like to see more
people adopt it, but I'm having trouble coming up with the point for this use.

~~~
aroman
Came here to say this. I feel the same way — even about the schema. Having a
poorly-organized or thought out resume should be an immediate signal to
employers. This eliminates that.

Of course, this is not to imply that having a really well-done resume is
really worth much either.

------
kalleboo
It took me until I got to the sample before I realized the page was talking
about Resumés, not resuming file uploads or something. It was very confusing.

------
nileshtrivedi
Nice. Now create a schema for job postings as well so that one can write a
crawler to find all interesting vacancies in one's favorite companies.

------
akusete
Looks cool, but Queensland is a state, not a region.

------
kijin
Looks cool, although it looks a bit U.S.-centric and techie-centric.

Other people have mentioned the firstName/lastName problem and the
region/state ambiguity. I'll mention a few more items that might be helpful if
you really want this to become a worldwide standard:

1\. In some countries, it is not only legal but also customary for employers
to ask for, and job seekers to include, various demographic information about
themselves that would be considered discriminatory in the U.S. For example,
sex/gender, date of birth, marriage status, and family details. It would be
good to define such fields in the schema but leave them optional. Or define a
catch-all field where anyone can add any key-value pair.

1-1. Don't forget the full street address, including the postal code!

1-2. Citizenship. This is very important for companies that might need to
sponsor your visa and/or geeen card.

1-3. In some countries, it is customary to include a photograph of yourself in
your resume. Perhaps this could take the form of a "photo" field that takes a
URL.

1-4. There needs to be a field where you can write down an alternate
expression of your name. Many Korean names can be written in either Hangul or
Hanja. Most Japanese names are written in Kanji, but often accompanied by
Hiragana to help the reader pronounce them properly. A lot of employers in
these countries require both forms.

2\. Since this is going to be electronically processed, perhaps it would be a
good idea to include the ticker code for publicly traded companies in one's
employment history? GOOG is much easier to search for than variations of
"Google", "Google Inc.", etc.

3\. The publications schema will need to be significantly expanded if you want
scientists and other academics to even consider using this. Take a look at how
academic publications are cited. At the very least, there needs to be a field
to specify the type of publication, e.g. book, ebook, edited book, journal
article, newspaper article, conference presentation, workshop presentation,
blog post, website, etc. There should also be a "doi" field for scientific and
other academic publications.

3-1. The education schema needs a "summary" field, just like the employment
schema.

4\. Some employers prefer to get the content of the reference from the referee
him/herself, rather than having the applicant include it in the resume.
(Otherwise, the applicant could modify the content.) So you need fields to put
the email address (to contact the referee) and a URL (to grab the content of
the reference) in the references field. Oh, and don't forget the referee's
employer and title/position. Those things matter.

4-1. Bonus points if the content of the reference can be authenticated with
the referee's PGP key.

4-2. Extra bonus points if the entire resume can be authenticated with the
applicant's PGP key, to prevent hiring agencies from messing with the content.

~~~
thomasfromcdnjs
Excellent feedback and you've set the bar high which is good! I don't have the
time to reply to each point at the moment but will definitely copy it over to
the issue tracker.

------
bitL
Ugh, what's the point? Hiring by robots?

------
edoceo
Another multi format resume/CV tool: [http://ars.io/](http://ars.io/)

------
auvrw
seemed like a good idea to me, although i didn't go the full 9 and write a
schema or anything.

[https://github.com/ransomw/ransomw.github.io/tree/master/med...](https://github.com/ransomw/ransomw.github.io/tree/master/media/resume)

------
Xophmeister
Beginning to wish I hadn't abandoned my modular JSON to LaTeX CV builder...
C'est la vie!

~~~
thomasfromcdnjs
ahh that would have been perfect!

------
pavanred
I keep thinking an ontology instead of JSON based resume would be a lot
better.

------
steve918
Seems like reinventing the wheel a bit here. Why not use jcard?

------
b3n
Could this be used with Namecoin (where JSON values are stored in a
blockchain)? Perhaps something like
[https://github.com/onenameio/onename](https://github.com/onenameio/onename)

~~~
tommorris
That'd be a great way to make a pointless format even more pointless. But,
sure.

------
sirji
Gravatar Url?

~~~
thomasfromcdnjs
We should be able to generate those from the email. Good suggestion though,
I'm going to add mine to my resume.

------
leed25d
Thanks, but I'll keep using LaTeX.

~~~
treve
I think you missed the point. It's not about displaying and formatting
resumes, it's about exchanging data between software.

------
exabrial
an XSD?

------
stevesunderland
this is f---ing brilliant.

------
korzun
As somebody who deals with hiring, who is going to use this exactly?

The only 'benefit' I see is that the crawlers/recruiters can parse your resume
easier.

Great for them; usually not so great for you.

~~~
lylejohnson
Are you kidding? With this, I can more easily skip over those applicants with
tons of Java and C++ development experience when I'm looking for a C#
developer. No more wasting time on reading resumes with completely unrelated
experience!

~~~
korzun
Why would I be kidding?

You are just backing up my point that recruiters will use it to grab your data
and filter you like a product.

There is absolutely no benefit to you as an engineer. Quality / noise ratio is
the issue here.

------
ttrbls
lol

------
sgonyea
lickMyAsshole.json

------
n0body
stupid

------
jimktrains2
Now, if only people will actually use this.

~~~
jimktrains2
To clarify, I meant that when looking for a job it is a pain to retype your
resume multiple times (because having a human look at candidates apparently
isn't a thing, especially at larger organizations). Having a standard format,
supported by many employers would have made the process much easier.

My resume is set up as
[http://www.microformats.org/wiki/hresume](http://www.microformats.org/wiki/hresume)
and noöne supports that, and it's been around for a while.

------
zak_mc_kracken
Nice try, LinkedIn.

