How to Create a CV With AI for Software and IT Roles

When you’re hiring for software and IT roles, the CV is going to be assessed in a very particular way. The recruiter is going to be looking for your tech stack, the scale of your work and what you’ve actually shipped. They’re going to be looking for evidence of your judgment and your links to code. The ATS will be searching for technology names. Your CV has to meet all of those needs in one or two pages so layout and prioritization are as important as the writing itself. An AI CV builder can help with the layout and the language; you just provide the stack, the numbers, and the links.

This guide covers what software and IT employers are looking for, how to structure your CV for the recruiter, the engineer and the AI, how to be honest about your technical skills, how to write the bullet points to demonstrate your impact, how to brief an AI CV writer for a technical role, what to edit and what not to edit, how to include your GitHub and portfolio links and the differences between a developer, an infrastructure role, a data role and an IT support role.

How to Create a CV With AI for Software and IT Roles

What employers screen for

  • Stack match. Languages, frameworks, databases, cloud platforms, tools, spelled as the posting spells them.
  • Scale and context. Users, requests, data volume, team size, system criticality.
  • Shipped work. Things that went to production and what they did.
  • Depth versus breadth. A list of forty technologies reads as shallow; a shorter list with evidence reads as deep.
  • GitHub, a portfolio, a published package, a talk, a blog post.
  • Design decisions explained, trade-offs acknowledged, incidents handled.
  • For IT support and infrastructure: certifications, systems administered, ticket volumes, uptime, incident response.

Structure

One page under about seven years; two beyond. In order:

  1. Name, contact, links. GitHub, LinkedIn, portfolio or personal site on one line.
  2. Role, specialism, years: “Backend Engineer | Go, Kubernetes, PostgreSQL | 6 years.”
  3. Three lines: what you build, at what scale, one standout fact.
  4. Technical skills. Grouped by type, limited to what you’d be interviewed on.
  5. Reverse chronological; employer, role, dates; three to five bullets per recent role with technologies named and results quantified.
  6. Open-source, side projects or notable work not captured above, with links and one line on adoption or outcome.
  7. Education and certifications. Brief; certifications with year for cloud, security and networking roles.

Technical skills: honest grouping

Group by type and keep the list defensible:

  • Languages: Go, Python, TypeScript
  • Frameworks and libraries: Gin, FastAPI, React
  • Data: PostgreSQL, Redis, Kafka
  • Infrastructure: Kubernetes, Terraform, AWS (EKS, RDS, S3)
  • Tools and practice: GitHub Actions, Prometheus, Grafana; TDD, code review

Omit anything you used once three years ago; interviewers probe skills sections, and a technology you can’t discuss costs more than one you left off. Avoid proficiency bars and percentages; they parse badly and mean nothing.

Bullets that show impact

Technical CVs tend to just list what you did: “Developed microservices”, “Maintained CI pipeline”, “Supported users” etc. What employers want to know is the outcome of your work. For each bullet point you should be able to say what you built or what you changed, what tech you used, the scale of it and the quantifiable result.

Before: “Worked on the payments service using Go and PostgreSQL.”

After: “Rewrote the payments retry logic in Go, cutting failed-transaction rate from 2.1% to 0.4% across ~1.2m daily transactions and removing roughly 30 support tickets a week.”

Before: “Managed the company’s cloud infrastructure.”

After: “Owned AWS infrastructure for a 40-engineer organization (EKS, RDS, S3); cut monthly spend 22% through right-sizing and reserved capacity; maintained 99.95% availability over 18 months.”

Metrics that software and IT work produces pretty readily: latency, throughput, error rates, uptime, cost, build and deploy times, ticket volumes and resolution times, test coverage, users served, incidents handled.

Briefing an AI CV maker

An ai cv maker takes notes or an old CV and a brief and returns a structured, formatted document with bullets written in impact language; Quillbot’s works in a browser, follows a technical brief, keeps technology names exact when told to, exports a parse-safe single-column PDF, and is free. A brief for a backend role:

Build a one page CV for a Senior Backend Engineer role at a fintech. Headline with specialism and years. Three line summary with scale. Technical skills in the following groups: Languages, Frameworks, Data, Infrastructure, Tools (only the technologies I list). Under each role 3-5 bullets with the technology, the scale and the measured result (using the figures I provide) – don’t change the technology names or version numbers. Projects section with GitHub links. Brief education and certs. No photo, no personal details. Here are my notes: [paste]

It’s vital to say “Include only the technologies I list” and “do not change technology names”. Otherwise the tools may go and add in some extra skills or alter/incorrectly label the technologies you’ve used.

Editing the generated CV

  • Check every technology name, version and acronym. Tools rename (“Postgres” to “PostgreSQL” is fine; “Kafka” to “Apache Spark” is not) and invent versions.
  • Check every number against your records.
  • Replace inflated verbs (“architected,” “spearheaded”) with what you did (“designed,” “built,” “led”).
  • Delete any technology you didn’t list and any section you didn’t ask for.
  • Confirm links work and point to current, presentable repositories.
  • Read as the engineer who’ll interview you.

GitHub, portfolio and links

For developer roles a GitHub profile with 2 or 3 pinned repos that have READMEs, tests and recent commits is generally more convincing than a CV. For infrastructure roles, a portfolio of Terraform or config examples, or a blog post about an incident, will do the same. For IT support a portfolio isn’t really expected; certs and ticket metrics are what matter. Just put the link on line 1 and in the projects section for a project (one line on what it does and any adoption metric (stars, downloads, users)).

If your best work is proprietary, then describe that in the experience section with sufficient technical detail to be believable and state that the code isn’t shareable. Interviewers will understand.

Role-specific emphasis

Backend and full-stack developers: services built, scale, performance and reliability numbers, data stores, API design, testing practice.

Frontend developers: frameworks, performance metrics (load time, Core Web Vitals), accessibility work, design-system contributions, a live portfolio.

Mobile developers: platforms, app store presence with download or rating figures, crash rates, release cadence.

Infrastructure, DevOps and SRE: cloud platforms with services named, IaC, CI/CD, uptime and incident metrics, cost reductions, on-call and incident response, certifications.

Data engineers and analysts: pipelines, volumes, tooling, data quality metrics, dashboards adopted, SQL and language depth.

Security: certifications, frameworks and standards, tooling, incidents handled, audits passed, vulnerability metrics.

IT support and systems administration: systems administered and user counts, ticket volumes and resolution times, uptime, migrations completed, certifications (CompTIA, Microsoft, Cisco), customer satisfaction scores.

QA and test: automation frameworks, coverage, defect metrics, release quality improvements.

A worked example: notes to CV

Notes for one role: “Platform engineer, e-commerce company, 2022 to now. Team of five looking after infra for about 60 engineers. AWS, EKS, Terraform, ArgoCD. Moved deployments from a Jenkins setup to GitOps with ArgoCD; deployment time went from ~40 minutes to under 8. Set up Prometheus and Grafana with alerting; p1 incidents went from about 6 a quarter to 2. On-call. Cut the AWS bill by about 18% with right-sizing and savings plans. Wrote the internal runbooks.”

Generated and reviewed:

Platform Engineer, [E-commerce Company] (2022–present) – One of five platform engineers supporting ~60 developers; AWS (EKS, RDS, S3), Terraform, ArgoCD – Migrated deployments from Jenkins to a GitOps workflow on ArgoCD, cutting typical deploy time from ~40 minutes to under 8 – Built monitoring and alerting on Prometheus and Grafana; P1 incidents fell from ~6 to ~2 per quarter – Reduced AWS spend ~18% through right-sizing and savings plans – Authored the team’s incident runbooks; on-call rotation

Every tech name came from the notes; the tool provided the structure and the compression. The review did spot one change: the tool had written “Jenkins to GitHub Actions,” which was incorrect, and that had been corrected.

Summaries for technical roles

Your summary should say what you build, at what scale and include one specific detail. Example: “Backend engineer with six years building payment and ledger services in Go and PostgreSQL for fintechs processing over a million transactions a day; led the migration of a monolith to services on a six person team.” Keep it to three lines, no adjectives please and include a number and a named technology. If it could apply to any engineer then rewrite it yourself.

Applicant tracking systems for technical roles

Technical recruiters will be searching on technology keywords so the posting needs to contain the exact terms: ‘Kubernetes’ (not just ‘k8s’) and ‘Amazon Web Services (AWS)’ once. Standard single-column layout with standard headings. No skill graphics. The paste-to-text check (select all, copy, and paste into a plain text editor) will confirm the document is being parsed in order.

Career changers and bootcamp graduates

Lead with the new skills and projects. Have a projects section right at the top with 2 or 3 substantial builds (deployed, with code links and a sentence on what each does and what you learned). The transferable experience from the previous field goes in a brief section. One page max. In the summary state what you’re looking for. Interviewers for junior roles are looking for evidence of you finishing things and of you learning; a deployed project with tests and a README is the perfect example of both.

Senior and lead roles

For staff, Principal, Lead and Manager roles your CV should reflect your scope i.e. the systems you owned, the teams you led and the budgets you managed. It should demonstrate the decisions you made (e.g. architectural decisions and their outcomes) and your influence (through setting the bar, hiring, mentoring etc). Technical depth is expected but it’s your judgement that is being assessed. Two pages is usually about right. Write your summary yourself and keep your older roles to one line.

Interviews follow the CV

Technical interviews will be asking you about the specifics in your CV (the numbers you’ve got, the design decisions you made, the technologies you’ve listed etc). If you build your CV from your own notes and edit it honestly, it becomes a guide for the stories you’re going to tell. If you use a tool and don’t go back and check the output you’re very likely to end up with things you can’t actually back up. You need to be able to talk about every bullet point for five minutes. That’s both an ethical check and good interview practice.

Common mistakes

  • Forty technologies in the skills section
  • Tasks instead of outcomes
  • No numbers
  • No links, or links to empty repositories
  • Technology names changed by the tool and not caught
  • Skill bars and two-column templates
  • Version numbers invented
  • A summary that would fit any engineer

Certifications in technical CVs

Cloud (AWS, Azure, GCP), security (Security+, CISSP, OSCP), networking (CCNA), platform (CKA, Terraform Associate), and vendor certs all matter in the context of hiring for infrastructure, security and IT support roles and are far less important in the case of pure software development. List them with the year and, where applicable, the expiry. For developer roles the projects section and the GitHub link are generally far more important than the certs. For IT support roles, the certs will often be the thing that gets you to the first screen.

Keeping the CV current

Technical careers change stack and scale so quickly and you end up rebuilding your CV from memory under pressure. Keep a running file of it (one line a month) with all the systems you’ve shipped with their numbers, all the technologies you’ve adopted, all the incidents you’ve dealt with, all the certs with their dates. That raw material is there when a posting comes along and you can then whip up a tailored CV in minutes.

Questions people ask

Should I list technologies I’ve only used briefly? Only if you’d be comfortable being interviewed on them. Otherwise, leave them off or mark them as familiarity in a separate line.

How do I show impact if I was one of many on a team? State your part: “owned the retry logic within a six-person payments team.” Specificity about your contribution is more credible than claiming the whole result.

One page or two? One under about seven years; two beyond, with the most relevant work on page one.

Is it fine to use an AI tool for a technical CV? Yes. Reviewers care about accuracy and specifics. The tool formats and phrases; you supply and verify the stack, the numbers and the links.

Cover note

Most technical roles will ask for a brief note. Four sentences please: the role you’re applying for, your tech stack and years’ experience, one shipped project relevant to the role with a number in it and a link to your code. Keep it under 100 words and in the body of the email. The engineers reading it will be looking for the link and the number, not a long paragraph about how excited you are.

Key points

  • Software and IT CVs are read by recruiters (stack and scale), engineers (judgment and code), and parsers (keywords); structure for all three.
  • Headline, three-line summary, grouped defensible skills, impact bullets with technology, scale and result, a projects section with links.
  • Brief the AI CV maker to keep technology names exact and include only listed skills; check every name, version and number.
  • Link to presentable code; describe proprietary work with technical specificity.
  • Adjust emphasis by role: metrics for backend and infra, portfolio for frontend and mobile, certifications and ticket metrics for IT support.
  • Single-column layout; exact posting terms where true; paste-to-text check.

Popular on OTW Right Now!

Add a Comment

Your email address will not be published. Required fields are marked *