For a technical candidate like a software developer, building the ideal resume can feel like an agonizing oxymoron, based on two points: 1) Like it or not, your resume will probably first be viewed by a recruiter who will have 15-30 seconds to look at some superficial things and 2) should your resume make it past the recruiter, it needs enough detail to impress an actual hiring manager.

So how do you create a resume simple enough for a recruiter to read quickly, and sophisticated enough to capture the attention of a technically savvy hiring manager?

Let’s do the more straightforward part (impressing the recruiter) first. Here are some simple tips to follow:

1) Use clean and simple formatting. Bold your name, titles, companies, and dates that you worked for them. Bold the headers of different sections (Objective, Professional Experience, Education, etc.) Don’t bold random buzzwords, don’t use paragraph form, don’t use tiny/ fancy fonts. If you’re a UI/UX or website designer, don’t get too fancy and make your resume unreadable. Opt for clean and professional lines.

2) Use bullet points when breaking down your job responsibilities under each position. If your resume is made up entirely of paragraphs, that might be enough of a tipping point for the recruiter to skip reading it.

3) If you’ve worked with older technologies in the past, consider obscuring them or even leaving them off your resume. For example, if in your list of technical skills on the back end, you have MongoDB, SQL Server 2010 and FoxPro, consider leaving out FoxPro altogether, especially if your familiarity with it stems from a migration project. (And if you’ve only ever worked with older technologies, you and I need to have a serious talk.).

4) Use keywords that recruiters will recognize and pick up in a Boolean search: Agile, SaaS, ASP.NET, C#, MVC, Java, J2EE, Swing, Hibernate, MongoDB, OOP, etc. You can’t be too specific, because different hiring managers will ask for different things, and what you think isn’t important to mention might actually be the foundation of a recruiter’s search.

5) Put the technology stack in each position. You might think one big technical summary somewhere in your resume suffices, but recruiters read all kinds of resumes, and developers switch gears all the time. Your resume needs to spell out where you have been working with what technology, what language, and for how long.

6) It’s ok for your resume to be more than one page if you’re not a junior candidate. Most developers have resumes that run two or three pages. Ten page-resumes, on the other hand, are too long (I have seen this).

The overall principle for getting past the recruiter - aka the gatekeeper — is to keep the look of the resume clean and simple, the words specific, and the technologies up-to-date.

Now to impress the hiring manager, assuming he is technically savvy:

1) Don’t just list buzzwords. Don’t put anything in your resume that you can’t talk about in an interview, and in detail. It is one of the greatest pet peeves of technical leads charged with interviewing potential candidates. Instead of listing words, describe exactly how you’ve applied the technologies in your various positions.

2) Don’t be vague. I’ve seen resumes in which each position was described in two or three blanket statements. Such resumes make hiring managers suspicious of your actual contribution to each project. Break it down into specifics.

3) If you’re a designer or mobile developer, include a link to your portfolio. I’m surprised by the number of front end/ designer resumes I see without a portfolio; it’s like asking for your resume to get shot down immediately.

4) Use recognizable benchmark-type words if you’ve mostly worked for smaller or relatively obscure companies. Include terms like enterprise, scalable, n-tier, high user counts, the number of people on your development team (if it’s more than five), etc. Don’t let hiring managers think you’re only capable of mom-and-pop production environments. They want to know that you understand process, fast-paced environments, larger-scale projects, etc.

The overall principle when writing your resume for a technical hiring manager is to leave him/ her with the impression: “This person can actually do what they say they can do.”

Still unsure of what to do? I’ve included below an excerpt of a favorite resume that I use as a sample for technical candidates. This one happens to be from a .NET Developer, but the principles he follows are the same as outlined above.

I wish you happy resume writing, and as always, best of luck in your job search!

-Joyce Jordan, Talent Relations

Excerpt from Sample Resume:

Software Developer

Company A, San Diego, CA, November 2009 – July 2011

Worked on ASP.NET MVC 2 and Web Forms applications following Agile and TDD methodologies. Helped build out a new middle tier that served as a Service-Oriented Architecture (SOA) platform which the company can use to centralize business logic amongst several disparate applications. This middle tier is largely code generated from meta-data allowing it to quickly and easily adapt to new requirements. Worked on a new ASP.NET 3.5 (C#) Web Forms application that consumed the new services. This new web application is entirely content injected using custom server controls and driven from meta-data. I specifically contributed to this project in the following ways:

· Created the meta-data management application (ASP.NET MVC 2 client, Sql Server) which was used to perform DML and DDL operations on the special purpose 5NF meta-data database. This database stored the configuration data of all routes, endpoints, content injection, data feeds and the meta-data required for code-generation of the middle tier.

· Administered permissions to control access to the different sections of meta-data management.

· Designed and built an ASP.NET MVC style routing engine for our Web Forms application using the ASP.NET routing framework.

· Designed and built a Rules Engine framework that was integrated into our core assembly. Other developers were later able to use it to implement several business logic rules.

· Worked with jQuery to add rich client functionality and encapsulate AJAX requests observing graceful degradation practices.

· Built a tree-view UI component which leveraged a State Pattern that replaced the Infragistics tree-view component and removed our dependency on the Infragistics assembly.

· Worked in an extremely rigorous OOP environment, observing SOLID principals, using Design Patterns and Architectural Patterns on a daily basis.

· Wrote several unit tests and test fixtures using NUnit.

Image via Sybren A. Stüvel