Back-End Developer Resume Examples by Experience Level
Backend Developer
A Backend Developer resume pairing each technology (Spring Boot 3.3, PostgreSQL 16, MySQL 8) with a measurable business result latency cuts, replica savings, and zero-downtime releases over vague coder claims.
Why this resume works:
- Shipped Spring Boot 3.3 services on PostgreSQL 16 handling 4K QPS at p99 under 120 ms
- Drove MySQL 8 query tuning that cut checkout latency 42% and freed 3 read replicas
- Led a squad of 4 engineers through an Agile roadmap with zero-downtime blue/green releases
Junior Backend Developer
This junior resume works because it quantifies early-career wins, endpoints shipped, coverage gained, tickets closed, and names the modern backend stack hiring managers actually screen for in 2026.
Why this resume works:
- Built 12 REST endpoints in Node.js 22 and Express.js for an internal billing service
- Added Jest and supertest coverage from 41% to 78%, catching 3 production-bound regressions
- Closed 60+ Jira tickets in first year including Redis 7 cache fixes and PostgreSQL index tuning
Senior Backend Developer
This senior resume works because it shows architectural ownership, a concrete latency win tied to a design decision, and the people-leverage metrics promotion committees expect at the senior level.
Why this resume works:
- Re-architected a Java 21 monolith into 9 Spring Boot services running on Kubernetes and Helm
- Cut p99 latency from 680 ms to 210 ms by introducing Kafka-based async workflows
- Reviewed 900+ PRs and mentored 5 mid-level engineers to promotion
Lead Backend Developer
This lead resume works because it reads like a staff-level narrative: multi-language scope, observability and reliability outcomes, and a credible dollar-level cost story recruiters can take to the hiring panel.
Why this resume works:
- Led 11-engineer backend org across Node.js, Go 1.22, and Python 3.12 services at Shopify
- Drove Kafka + OpenTelemetry rollout that took on-call pages from 38 to 6 per week
- Owned the FY roadmap that delivered a 3.2x QPS scale-up while cutting infra spend by $1.1M
Backend Intern
A Backend Intern resume that treats a DoorDash internship like a real engineering role: a shipped FastAPI service, a CI runtime improvement, and a SQLAlchemy OSS PR give recruiters three concrete signals over coursework.
Why this resume works:
- Built a FastAPI service for internal feature flags used by 4 product teams at DoorDash
- Wrote 40+ pytest cases and set up GitHub Actions CI that cut build time from 9 to 3 minutes
- Contributed a documentation fix merged into the open-source SQLAlchemy project
Backend Engineer
This backend engineer resume works because it stacks three of the hardest problems on the job, protocol design, database cost, and live data migration, and pairs each with the metric that proves the outcome.
Why this resume works:
- Designed NestJS + gRPC services handling 18K RPS peak at Uber with p99 under 95 ms
- Reduced MongoDB 7 storage cost 34% through schema refactor and TTL index strategy
- Owned zero-downtime migration of 2.4B rows from Cassandra to DynamoDB over a quarter
API Developer
This API developer resume works because it leads with API surface size, security posture, and developer-experience metrics, the three things partners, platform teams, and hiring managers all grade on.
Why this resume works:
- Published 60+ REST and GraphQL Apollo endpoints behind an OpenAPI 3.1 contract at Stripe
- Rolled out OAuth 2.1 + rate limiting across 4 public products with zero auth regressions
- Cut partner integration time from 11 days to 3 with auto-generated SDKs in 5 languages
Microservices Developer
A Microservices Developer resume telling a full decomposition story: 14 services from a 420K-LOC Spring Boot monolith, OpenTelemetry observability, and a saga orchestrator how staff engineers evaluate in 2026.
Why this resume works:
- Decomposed a 420K-LOC Spring Boot monolith into 14 Dockerized services on Kubernetes
- Introduced OpenTelemetry + Prometheus, dropping mean time to detection from 22 to 4 minutes
- Shipped a saga-pattern orchestrator that eliminated 97% of distributed-transaction rollbacks
Junior Back-End Developer
This junior back-end developer resume works because it proves consistent ticket delivery, pairs that with a senior-reviewed performance win, and closes with a credential recruiters use as an entry-level filter.
Why this resume works:
- Delivered 28 JIRA stories across Django 5 and FastAPI services in 18 months at Reddit
- Partnered with 2 senior engineers on a Redis 7 caching layer that halved dashboard load time
- Earned AWS Certified Developer – Associate during first year on the job
Senior Back-End Developer
This senior back-end developer resume works because it combines brand-name tenure, a high-stakes migration with a time-box, and a written artifact that proves cross-team technical influence beyond one squad.
Why this resume works:
- Eight years building high-throughput Go 1.22 and Node.js 22 services at Spotify and Datadog
- Led a zero-downtime migration of a 9TB MySQL 8 cluster to partitioned Aurora in 6 weeks
- Authored an RFC on Kafka consumer backpressure now used by 4 squads across the org
Web Services Developer
A Web Services Developer resume that frames the role in integration and cost terms: 9 systems and 3 partners connected, 2 legacy ESBs removed, and $380K saved the business framing enterprise hiring managers screen on.
Why this resume works:
- Built REST and SOAP integrations between 9 internal systems and 3 third-party partners at MongoDB
- Shipped a.NET 8 service bus that replaced 2 legacy ESB products and saved $380K annually
- Cut partner onboarding from 6 weeks to 8 days with a self-serve sandbox and mock server
Back-end Java Developer
This Java backend resume works because it leans into modern JVM specifics, virtual threads, ZGC, contract tests, instead of a generic Java skills dump, which is how senior interviewers separate fluent Java engineers from list-readers.
Why this resume works:
- Shipped Spring Boot 3.3 services on Java 21 virtual threads at Airbnb, handling 6K RPS per pod
- Reduced GC pauses from 340 ms to 55 ms by migrating to ZGC and tuning heap sizing
- Introduced Testcontainers and Pact, catching 11 contract-breaking changes before release
Lead Back-End Developer
This lead back-end developer resume works because it balances people outcomes with a concrete DevOps lead-time metric, which is what modern engineering directors want to see on a lead's first page.
Why this resume works:
- Led a 9-engineer backend group across Python 3.12 FastAPI and Go 1.22 services at Meta
- Owned a platform migration to ArgoCD + Helm that cut deploy lead time from 52 to 11 minutes
- Grew staff coverage for on-call from 2 to 7 senior ICs through focused mentorship
Microservices Architect
This microservices architect resume works because it showcases scale, org-wide written influence, and the two Kubernetes certifications that signal practical platform depth to staff-plus interviewers.
Why this resume works:
- Designed a 22-service mesh on Kubernetes + Istio that scaled to 120K RPS at Google Cloud
- Authored the service-boundary RFC now adopted by 3 business units and 40+ engineers
- Held CKAD and CKA certifications, driving a platform-wide Helm chart standard
Entry-Level Back-End Developer
This entry-level resume works because it substitutes real capstone metrics and a deployed portfolio project for the work experience a new grad doesn't have yet, giving the recruiter proof of hands-on ability.
Why this resume works:
- Built two Node.js 22 + Express.js capstone APIs with 91% Jest coverage and CI on GitHub Actions
- Deployed a personal project on Docker and Render serving 200 concurrent users in load tests
- BS in Computer Science, 3.7 GPA, with coursework in distributed systems and databases
Backend Python Developer
This Python backend resume works because it pairs the exact framework mix recruiters search for with a messaging swap and tooling rollout that prove the candidate owns code quality beyond their own tickets.
Why this resume works:
- Shipped Django 5 and FastAPI services on Python 3.12 across 3 product surfaces at DoorDash
- Cut async task latency 58% by moving from Celery to NATS + asyncio workers
- Maintained 89% pytest coverage and drove a ruff + mypy rollout across 11 repos
Java Backend Developer
This Java backend developer resume works because it speaks fluently about exactly-once semantics and benchmark-driven rewrites, which are the two technical signals senior JVM hiring managers use to separate strong candidates from fine ones.
Why this resume works:
- Six years on Spring Boot 3.3 + Java 21, primarily on payments services at Stripe
- Drove a Kafka exactly-once refactor that eliminated 99.4% of duplicate settlement events
- Ran JMH benchmarks that guided a rewrite delivering 2.7x throughput on a hot ledger path
Python Backend Developer
This Python backend developer resume works because the framework migration is scoped with a realistic timeline and the p99 cut is tied to an observability investment, not a buzzword, which is how engineering managers verify ownership.
Why this resume works:
- Built FastAPI services on Python 3.12 handling 2.2K QPS behind a Redis 7 cache at Reddit
- Migrated 140 endpoints from Flask to FastAPI with zero downtime in 9 weeks
- Added OpenTelemetry traces that let the team cut p99 from 410 ms to 140 ms
Backend Developer Python
This Python backend resume works because it proves data-scale fluency, a database win grounded in a specific ORM upgrade, and a CI improvement that saves the whole team time every day.
Why this resume works:
- Shipped a Python 3.12 ingestion service handling 18M events/day through Kafka and PostgreSQL 16
- Replaced raw SQL hot paths with SQLAlchemy 2.0 async patterns, cutting DB CPU by 29%
- Owned a monorepo Poetry + Nx setup that reduced CI runtime from 23 to 7 minutes
What Recruiters Want to See on Your Back-End Developer Resume
- Core Languages: Fluency in at least one of Node.js 22, Python 3.12, Java 21, Go 1.22, or.NET 8, named by version, not as a bullet list.
- Database Depth: Hands-on work with PostgreSQL 16, MySQL 8, MongoDB 7, Redis 7, and at least one of Cassandra or DynamoDB.
- API Design: REST, GraphQL (Apollo), and gRPC exposure with OpenAPI 3.1 contracts, versioning, and auth patterns like OAuth 2.1.
- Messaging & Streaming: Production experience with Kafka, RabbitMQ, or NATS, including ordering, retries, and backpressure.
- Containers & Orchestration: Docker, Kubernetes, and Helm for real deployments, bonus for service-mesh or ArgoCD.
- Observability: OpenTelemetry, Prometheus, Grafana, or Datadog tied to concrete latency or error-rate wins.
- CI/CD Ownership: GitHub Actions, Jenkins, or ArgoCD pipelines the candidate built or meaningfully improved.
- Quantified Impact: p99 latency cuts, QPS scale, cost saved, test coverage lifted, incidents reduced, numbers, not adjectives.
- Security Posture: Awareness of OWASP Top 10, secret management, and zero-downtime migration patterns.
- Collaboration Signals: PR review volume, mentorship, RFC authorship, and on-call coverage.
Expert Tips for Tailoring Your Back-End Developer Resume
- •Match the Stack Exactly: If the job names PostgreSQL and Kafka, your resume should name the same versions, not a generic “RDBMS and message queue.”
- •Lead Every Bullet With a Verb: Shipped, migrated, cut, designed, owned. Never “responsible for.”
- •Show the Metric and the Mechanism: “Cut p99 42% by adding Redis 7 write-through caching” beats “improved performance.”
- •Keep Three Strong Projects: A monolith-to-microservices decomposition, a zero-downtime migration, and one OSS contribution covers most backend interview loops.
- •Format for the ATS First: Standard section headings, no tables in the experience section, and PDF export from a plain template.
How to write a back-end developer resume
How to write a back-end developer summary or objective
What Makes an Effective Back-End Developer Summary
- •Names the primary language, framework, and database versions you lead with.
- •Shows one signature outcome, a latency cut, a scale milestone, or an infra saving.
- •Mentions the class of systems you’ve built (payments, feed, billing, search, etc.).
- •Aligns the exact keywords with the target job description.
- •Ends with the role or impact you want next, in one crisp line.
- Title Line: “Senior Back-End Developer with 7 years on Java 21 and Spring Boot 3.3.”
- Stack Line: Name 3–5 core technologies you actually lead with, Node.js 22, Python 3.12, PostgreSQL 16, Kafka, Kubernetes.
- Signature Win: One quantified outcome, e.g., “cut p99 latency 60% on a 2K-QPS billing service.”
- Domain: Mention the problem space (payments, streaming, ads, logistics) that matches the target role.
- Forward Intent: One sentence describing the scope you’re stepping into next.
- Tone: Plainspoken, first-person or neutral, zero filler adjectives.
Common Mistakes to Avoid in a Back-End Developer Summary
- •Starting with “Highly motivated”, it’s read as filler by recruiters and AI screeners.
- •Listing 12 technologies with no version numbers or context.
- •Describing front-end work instead of back-end depth.
- •Skipping the signature metric, a summary without one number is forgettable.
- •Re-using the same summary across every application.
How to Tailor for Different Experience Levels
Entry-level candidates should highlight capstone projects, internships, and OSS contributions. Mid-level engineers emphasize delivery velocity, code quality, and one or two signature wins. Senior and lead engineers focus on architectural decisions, cross-team influence, and dollar or reliability outcomes.
Do this
- Do name versions: Node.js 22, Python 3.12, Java 21, PostgreSQL 16.
- Do show one signature win per role with a specific number.
- Do keep the summary under 4 lines.
- Do tailor the keywords to the specific job posting.
Avoid this
- Don’t open with soft-skill adjectives like “passionate” or “motivated.”
- Don’t list every framework you’ve ever touched.
- Don’t reuse the same generic paragraph across applications.
- Don’t describe duties; describe outcomes.
Resume Summary Examples for Back-End Developers
Entry-Level Back-End Developer
Recent Computer Science graduate with 18 months of hands-on Node.js 22 and Python 3.12 work across two capstone APIs and an open-source contribution to SQLAlchemy. Delivered a FastAPI billing service for 4 product teams during a DoorDash internship with 91% pytest coverage. Seeking an entry-level back-end role where I can own services end to end on a modern Kubernetes stack.
Mid-Level Back-End Developer
Back-End Developer with 5 years on Spring Boot 3.3 and Java 21, most recently at Shopify. Cut p99 checkout latency 42% by re-tuning PostgreSQL 16 indexes and introducing Redis 7 caching, and maintained 86% test coverage on a 2.1K-QPS service. Looking to step into a senior backend role focused on high-throughput commerce systems.
Senior-Level Back-End Developer
Senior Back-End Developer with 10+ years across Netflix, Spotify, and Datadog, specializing in Kafka-driven microservices on Java 21 and Go 1.22. Led a 9-service decomposition on Kubernetes that scaled to 18K RPS and cut infra spend by $1.1M annually. AWS Developer Associate and CKAD certified, looking to lead backend architecture for a platform team.
How to write a back-end developer work experience
Your work experience section is where hiring managers decide whether to schedule an interview. For back-end roles in 2026, that means every bullet should name the stack, describe the decision you owned, and close with a number, latency, QPS, cost, coverage, incidents, or lead time.
- Anchor the Role: Title, company, dates, and a one-line summary of what the team owned, e.g., “Back-End Developer, Stripe, Jan 2023 – Present; payments platform.”
- Lead With a Verb: Shipped, migrated, cut, designed, owned, rolled out. Never start with “responsible for” or “helped with.”
- Name the Stack in the Bullet: “Spring Boot 3.3 on Java 21” beats “modern Java.” Version numbers signal currency.
- Quantify the Outcome: p99 latency cuts, QPS scale, infrastructure cost saved, test coverage lifted, zero-downtime migrations. At least 60% of bullets should carry a number.
- Handle Gaps and Switches Cleanly: Describe side projects or OSS contributions during gaps; for short tenures, state the outcome shipped regardless of how long you were there.
Expert Tip: Tailoring Your Experience
Rewrite three to five bullets for each application so the stack and scale match the target job.
- •Mirror the job description’s language for languages, databases, and tooling.
- •Move the most relevant bullet to the top of each role, even if it wasn’t chronologically first.
Work Experience Examples for Back-End Developers
Entry-Level Back-End Developer Work Experience Example
Back-End Developer Intern, DoorDash, Jun 2025 – Dec 2025
- Built a FastAPI feature-flag service on Python 3.12 used by 4 product teams in production.
- Wrote 40+ pytest cases and set up GitHub Actions CI that cut build time from 9 to 3 minutes.
- Contributed a documentation fix merged into the SQLAlchemy open-source project.
- Paired weekly with 2 senior engineers on a Redis 7 caching layer that halved dashboard load time.
Mid-Level Back-End Developer Work Experience Example
Back-End Developer, Shopify, Apr 2022 – Present
- Shipped Spring Boot 3.3 services on PostgreSQL 16 handling 4K QPS at p99 under 120 ms.
- Drove MySQL 8 query tuning that cut checkout latency 42% and freed 3 read replicas.
- Rolled out OpenTelemetry traces and Grafana dashboards, cutting MTTR from 28 to 9 minutes.
- Mentored 2 junior engineers through their first on-call rotations and promotion cycles.
Senior-Level Back-End Developer Work Experience Example
Senior Back-End Developer, Datadog, Feb 2020 – Mar 2026
- Re-architected a Java 21 monolith into 9 Spring Boot services on Kubernetes + Helm.
- Cut p99 latency from 680 ms to 210 ms by introducing Kafka-based async workflows.
- Led a zero-downtime migration of a 9TB MySQL 8 cluster to partitioned Aurora in 6 weeks.
- Authored the Kafka consumer backpressure RFC now used by 4 squads, and reviewed 900+ PRs.
Top hard skills and soft skills for back-end developer resumes in 2026
| Hard Skills | Soft Skills |
|---|---|
| Node.js 22 / Python 3.12 / Java 21 / Go 1.22 /.NET 8 | Technical Communication |
| Spring Boot 3.3, Django 5, FastAPI, NestJS, Express.js | Ownership |
| REST, GraphQL Apollo, gRPC, OpenAPI 3.1 | Cross-Team Collaboration |
| PostgreSQL 16, MySQL 8, MongoDB 7, Redis 7 | Problem Decomposition |
| Cassandra, DynamoDB, partitioning & sharding | Pragmatism |
| Kafka, RabbitMQ, NATS | Mentorship |
| Docker, Kubernetes, Helm, ArgoCD | On-Call Maturity |
| GitHub Actions, Jenkins CI/CD | RFC Writing |
| OpenTelemetry, Prometheus, Grafana, Datadog | Debugging Rigor |
| Zero-downtime migrations & feature flags | Calm Incident Response |
Best certifications for back-end developer resumes in 2026
- AWS Certified Developer – Associate: The most recognizable cloud credential for backend engineers building on AWS primitives like Lambda, API Gateway, DynamoDB, and SQS.
- Certified Kubernetes Application Developer (CKAD): Proves you can build, deploy, and debug workloads on Kubernetes — table stakes at any platform-adjacent backend role.
- Certified Kubernetes Administrator (CKA): Signals deeper operational depth for lead and staff candidates who influence cluster design and on-call.
- HashiCorp Certified: Terraform Associate: Useful for backend engineers who own infra-as-code for their services on top of Kubernetes or cloud-native platforms.
- Microsoft Certified: Azure Developer Associate: Strong signal for.NET 8 backend candidates targeting Azure-centric employers.
- Google Professional Cloud Developer: Validates GCP-specific patterns for backend teams running on Cloud Run, Pub/Sub, and Spanner.
- Confluent Certified Developer for Apache Kafka: Increasingly asked for by teams running event-driven architectures in production.
- MongoDB Associate Developer: Worth adding when the target role leans heavily on document modeling and aggregation pipelines.
How to format your back-end developer resume
Entry-Level Back-End Developer
- •Lead with projects and internships, deployed capstones count as real experience.
- •Name specific versions: Node.js 22, Python 3.12, PostgreSQL 16.
- •Include one OSS contribution or a merged PR to signal initiative.
- •List relevant certifications like AWS Developer Associate if earned.
Mid-Level Back-End Developer
- •Lead every role with one signature outcome, a latency cut, a migration, or a cost saving.
- •Show API and database depth: REST or gRPC, PostgreSQL or MongoDB with query tuning examples.
- •Include test coverage numbers and CI/CD improvements you personally drove.
- •Mention on-call, review volume, or mentorship to signal readiness for senior scope.
Senior Back-End Developer
- •Open with architecture-level wins: decompositions, migrations, or platform rollouts.
- •Quantify scale (QPS, data volume) and cost ($ saved, headcount multiplied).
- •Reference written artifacts — RFCs, design docs — to prove cross-team influence.
- •List CKAD, CKA, or AWS Developer Associate to reinforce infra credibility.
Avoid multi-column designs, colored headers, and icons inside bullet lists, modern ATS screeners still misread them, and strong backend content doesn’t need decoration.
- Use a single-column template with a professional font like Inter, Calibri, or Arial at 10–11pt.
- Put contact info, GitHub, and LinkedIn in the header, skip the street address.
- Write a 3–4 line summary naming your stack, domain, and signature win.
- Use clear section headings: Experience, Projects, Skills, Education, Certifications.
- Lead every experience bullet with a verb and close with a number where possible.
- Keep it to one page up to 7 years of experience, two pages beyond that.
- Export as PDF with selectable text, never as a flattened image.
Customization Tip
For every application, rewrite three to five bullets so the stack, scale, and domain mirror the job description. It takes 15 minutes and meaningfully lifts callback rates.
Common Mistakes to Avoid
Do this
- Name languages, frameworks, and databases with version numbers.
- Pair every win with a number: p99, QPS, $, coverage %, or incidents.
- Show one signature architectural decision per senior-level role.
- Include API design specifics: REST, GraphQL Apollo, gRPC, OpenAPI 3.1.
- Mention your CI/CD tooling and one concrete lead-time improvement.
- List observability stack (OpenTelemetry, Prometheus, Datadog) with outcomes.
- Reference relevant certifications (AWS Developer Associate, CKAD, CKA).
- Lead every bullet with a strong verb: shipped, migrated, cut, designed, owned.
Avoid this
- Don’t pad the resume with front-end work that doesn’t match a backend job.
- Don’t open the summary with “Highly motivated” or “Passionate.”
- Don’t list 20 technologies with no context or version numbers.
- Don’t claim “improved performance” without a number or mechanism.
- Don’t hide database work under a generic “SQL” bullet.
- Don’t use multi-column templates that break ATS parsing.
- Don’t skip links to GitHub or deployed demos when you have them.
- Don’t ship a resume without proofreading it end to end for typos.
Key Takeaways for Your Back-End Developer Resume
Essential Resume Tips for Back-End Developers
- •Name Your Stack Precisely: Node.js 22, Python 3.12, Java 21, PostgreSQL 16 — versions matter.
- •Quantify Every Role: At least one signature metric per job: p99, QPS, $ saved, or incidents cut.
- •Show Architectural Thinking: A migration, decomposition, or RFC beats a list of tickets closed.
- •Demonstrate Observability: Tie OpenTelemetry, Prometheus, or Datadog work to a measurable win.
- •Include Relevant Certifications: AWS Developer Associate and CKAD/CKA carry real weight.
- •Tailor Every Time: Rewrite the top three bullets per application to mirror the target stack.
Back-End Developer Resume FAQ
A modern Back-End Developer resume starts with Contact Info (email, phone, GitHub, LinkedIn), a Summary naming your stack and one signature win, a Technical Skills block grouped by language, database, messaging, containers, and observability, a Work Experience section with quantified bullets, an Education section, and, especially for mid and senior candidates, Projects, Certifications, and open-source contributions.
Use a single-column template with a clean sans-serif font at 10–11pt. Keep section headings plain, avoid icons inside bullet lists, and export as a PDF with selectable text. One page is right up to 7 years of experience; two pages is fine beyond that. Most ATS screeners still misparse multi-column designs, so even a beautiful template can hurt callback rates.
Lead with your primary language and framework by version — for example, Java 21 with Spring Boot 3.3, or Python 3.12 with FastAPI. Back that up with a database (PostgreSQL 16, MySQL 8, MongoDB 7, or DynamoDB), a messaging system (Kafka, RabbitMQ, or NATS), container tooling (Docker, Kubernetes, Helm), and an observability stack (OpenTelemetry, Prometheus, Datadog). Mirror the job description’s language so the ATS matches cleanly.
Every bullet should lead with a strong verb, name the stack, and close with a number. “Cut p99 latency from 680 ms to 210 ms by introducing Kafka-based async workflows” works because it shows the outcome, the magnitude, and the mechanism. At least 60% of your bullets should carry a metric — p99, QPS, cost saved, coverage lifted, or incidents reduced — or they’ll read as duties rather than outcomes.
Yes, especially for entry-level and mid-level candidates. A deployed side project or a merged open-source PR proves you can ship without a manager behind you. Describe the problem, the stack, and the outcome: “Built a Node.js 22 + PostgreSQL 16 URL-shortener deployed on Fly.io, serving 200 concurrent users in load tests.” Skip anything stalled, half-finished, or older than two years unless it’s genuinely load-bearing for the target role.
It’s optional for most product and platform roles, but still useful when you’re switching domains (e.g., ads to fintech) or when the company explicitly asks for one. Keep it to three short paragraphs: why this company and role, one story that matches their top priority, and a close pointing to your GitHub or a deployed project. Avoid repeating your resume verbatim — cover letters work when they add context, not when they restate bullets.
Share article