Organize resumes by company in subdirectories

- Create subdirectories for each company (files/, valon/) - Move company-specific resumes and cover letters to their directories - Update Makefile to support FILE_NAME paths (e.g., files/resume-name) - Improve clean target to recursively find .log files - Update CLAUDE.md with new directory structure documentation - Add examples for building PDFs from subdirectories - Document cover letter placement and usage This improves organization as more job-specific resumes accumulate. Files can now be organized by company for easier management. Makefile usage: make resume # root directory (default) make resume FILE_NAME=files/paul-halvorsen-files-backend-engineer make resume FILE_NAME=valon/paul-halvorsen-valon-software-engineer Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
2026-03-05 16:07:43 -05:00
parent 649f84aff7
commit 697312036f
8 changed files with 226 additions and 19 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,29 +8,50 @@ This is a resume builder using Pandoc to convert Markdown resumes with YAML meta

 ## Build and Development Commands

-**Build the resume PDF:**
-```bash
-# Build default resume
-make resume
-
-# Build a custom resume with a specific filename
-make resume FILE_NAME=paul-halvorsen-acme-senior-backend-engineer
+**Directory Structure:**
+Resumes are organized by company in subdirectories for easy management:
+```
+.
+├── paul-halvorsen-resume.md          (default/main resume)
+├── files/
+│   ├── paul-halvorsen-files-backend-engineer.md
+│   └── paul-halvorsen-files-backend-engineer.pdf
+├── valon/
+│   ├── paul-halvorsen-valon-software-engineer.md
+│   ├── paul-halvorsen-valon-cover-letter.md
+│   └── paul-halvorsen-valon-software-engineer.pdf
+└── [company]/
+    └── paul-halvorsen-[company]-[role].md
 ```

-The `FILE_NAME` variable defaults to `paul-halvorsen-resume` but can be overridden to use any markdown file in the directory (without the `.md` extension). The Makefile will:
+**Build the resume PDF:**
+```bash
+# Build default resume (root directory)
+make resume
+
+# Build a custom resume from a company subdirectory
+make resume FILE_NAME=files/paul-halvorsen-files-backend-engineer
+make resume FILE_NAME=valon/paul-halvorsen-valon-software-engineer
+
+# Build a new resume (can be in any directory)
+make resume FILE_NAME=[company]/paul-halvorsen-[company]-[role]
+```
+
+The `FILE_NAME` variable defaults to `paul-halvorsen-resume` but can be overridden to include a path. The Makefile will:
 1. Build the Podman image if it doesn't exist
 2. Convert the markdown file to PDF using the default LaTeX template
-3. Output a PDF with the same name as the input markdown file (but with `.pdf` extension)
+3. Output a PDF with the same filename (but with `.pdf` extension) in the same directory

 **Example workflow for custom resumes:**
 ```bash
-# Create a customized markdown resume
+# Create a customized markdown resume in company directory
+mkdir -p acme
 # paul-halvorsen-acme-senior-backend-engineer.md

 # Build it
-make resume FILE_NAME=paul-halvorsen-acme-senior-backend-engineer
+make resume FILE_NAME=acme/paul-halvorsen-acme-senior-backend-engineer

-# Output: paul-halvorsen-acme-senior-backend-engineer.pdf
+# Output: acme/paul-halvorsen-acme-senior-backend-engineer.pdf
 ```

 **Clean commands:**
@@ -115,16 +136,19 @@ To build a different version, either:
 The detailed resume (`paul-halvorsen-resume-detailed.md`) contains comprehensive information across all roles and projects. To create a customized resume for a specific job application:

 1. **Get job description** - Copy the job posting or description
-2. **Provide to Claude Code** - Share the job description with Claude Code along with a request to create a customized resume
-3. **Output format** - Claude will create a new markdown file using the naming convention:
+2. **Provide to Claude Code** - Share the job description with Claude Code along with a request to create a customized resume (and optionally a cover letter)
+3. **Output format** - Claude will create markdown files in a company subdirectory using the naming convention:
   ```
-   paul-halvorsen-[company-name]-[role-title].md
+   [company]/paul-halvorsen-[company-name]-[role-title].md
+   [company]/paul-halvorsen-[company-name]-cover-letter.md  (optional)
   ```
-   Example: `paul-halvorsen-stripe-senior-rust-engineer.md`
+   Example:
+   - `stripe/paul-halvorsen-stripe-senior-rust-engineer.md`
+   - `stripe/paul-halvorsen-stripe-cover-letter.md`

-4. **Build the PDF** - Generate the PDF using:
+4. **Build the PDF** - Generate the PDF(s) using:
   ```bash
-   make resume FILE_NAME=paul-halvorsen-stripe-senior-rust-engineer
+   make resume FILE_NAME=stripe/paul-halvorsen-stripe-senior-rust-engineer
   ```

 5. **Expected result** - A 1-2 page resume tailored to the job requirements with:
@@ -132,5 +156,9 @@ The detailed resume (`paul-halvorsen-resume-detailed.md`) contains comprehensive
   - Emphasized skills and metrics matching the job description
   - Highlighted relevant accomplishments and projects
   - Customized summary/intro focused on the role
+   - Optional: A compelling cover letter explaining interest in the company/role
+
+**Note on Cover Letters:**
+Cover letters are stored as markdown files in the same company directory as the corresponding resume. They can be included when submitting applications through platforms that support them, or converted to PDF by saving as plain text/PDF from a markdown editor.

 The detailed resume includes proficiency levels, performance metrics, specializations, and comprehensive technical details that allow Claude Code to intelligently match your background to specific job requirements.
--- a/2
+++ b/2
@@ -31,7 +31,7 @@ cleanpodman:
 	if [ ${CONTAINER_EXISTS} -ne 0 ]; then podman image rm -f ${NAME} && rm -f .podman-build; fi

 clean:
-	rm -f *.log
+	find . -name "*.log" -type f -delete

 cleanall: clean cleanpaper cleanpodman
 	@echo "Cleanup everything"
--- a/files/paul-halvorsen-files-backend-engineer.md
+++ b/files/paul-halvorsen-files-backend-engineer.md
@@ -0,0 +1,84 @@
+---
+name: Paul Halvorsen
+keywords: backend engineer, distributed systems, Python, GoLang, performance optimization, CI/CD, Redis, Elasticsearch, AWS, API design, scale, testing, TDD
+left-column:
+    - 'Sr Backend Engineer'
+    - 'Email: [paul.halvorsen@pm.me](mailto:paul.halvorsen@pm.me)'
+    - 'Phone: +1-410-236-4665'
+right-column:
+    - 'LinkedIn: [www.linkedin.com/in/paul-halvorsen](www.linkedin.com/in/paul-halvorsen)'
+    - 'Git: [https://git.halvo.me/paul](https://git.halvo.me/paul)'
+    - 'Blog: [https://flow.halvo.me](https://flow.halvo.me)'
+---
+
+# Summary
+
+Backend engineer with 15+ years building systems at scale. Expert in designing distributed systems that process billions of events daily with focus on performance, reliability, and maintainability. Polyglot developer (Python, GoLang, C, Rust) comfortable learning new languages and frameworks. Proven track record of end-to-end ownership in high-autonomy environments, from architecture to production support. Passionate about clean code, testing, and pushing systems to their limits.
+
+# Work Experience
+
+## Abnormal AI
+
+**Software Engineer**: Jan 2026 - Present (Remote)
+
+- **Infrastructure at Scale**: Build and maintain 10 Kubernetes clusters across US East, US West, EU West, and government regions with auto-scaling and sophisticated deployment pipelines
+- **Distributed Data Systems**: Architect and maintain services that aggregate real-time and long-term storage for multiple customers simultaneously
+  - Python and GoLang microservices
+  - Comprehensive pytest-driven test coverage and unit testing at all layers
+  - Designed for auto-scaling to increase efficiency and reduce costs
+  - Implemented compression strategies for large-scale data management
+- **API & Job Systems**: Build cron job orchestration in Kubernetes, manage RBAC across infrastructure
+- **Ownership**: Own meaningful outcomes across full stack - design, implementation, deployment, monitoring
+- **Collaboration**: Heavy inter-team communication in monorepo environment with shared ownership model
+- **Team**: Work with 5-person engineering team in flat, high-trust structure
+
+## Binary Defense
+
+**Sr Software Engineer**: April 2022 - Oct 2025
+
+- **Large-Scale Backend Systems**: Engineered systems serving Fortune 500 companies with thousands of endpoints, handling billions of events daily
+- **Performance Optimization** - Demonstrated deep expertise in identifying and eliminating bottlenecks:
+  - Reduced CPU usage by 90% through intelligent filtering of previously observed issues
+  - Reduced memory consumption by 60% using regex patterns and targeted filtering
+  - Reduced network traffic by 80% through data transformation and optimization
+  - Reduced disk storage by 20% by converting multiple string patterns to compiled regex
+- **Distributed Event Processing**: Built multi-platform event streaming libraries (Windows, Linux, macOS) with event-driven architecture watching filesystem, user, Windows events, and network changes
+  - White/blacklist systems with complex filtering logic
+  - Data sanitization, decoration, and serialization for backend transmission
+  - De-duplication to reduce network load and backend storage costs
+- **Infrastructure & Deployment**: GitLab CI/CD pipelines for cross-platform testing and deployment (Docker, Windows VMs, macOS)
+  - Integration testing across VMs, temporary servers, and pre-configured environments
+  - Cross-compilation for multiple OS targets (Windows Server 2009-2019, Windows XP-11, Linux, macOS)
+- **Technology Stack**: Rust (tokio, reqwest, serde), Python (pyenv, pipenv, cython), Docker, SQLite with encryption, Azure API integrations
+- **Code Quality**: Nextest and unit testing at all layers; writing RFCs and ADRs to drive architectural decisions
+- **Team Dynamics**: SCRUM-based environment with high code review standards and collaborative architecture discussions
+
+## Kyrus Tech
+
+**Sr Software Engineer**: Nov 2020 - April 2022
+
+- **Distributed Systems Design**: Built covert communication systems with Apache Thrift, HTTPS, and REST APIs routing through multiple layers
+  - Multi-threaded architecture with RSA key exchange and encrypted transfers
+  - C front-end, middleware, Python backend composition
+- **Test-Driven Development**: Implemented comprehensive testing strategy using C, Python, and Pytest within GitLab CI/CD
+- **Low-Level Systems**: Router fingerprinting and vulnerability analysis on Android with compact/rolling log aggregation
+
+# Technical Skills
+
+**Distributed Systems**: Kubernetes (10+ clusters), microservices architecture, event-driven design, job orchestration, auto-scaling, cross-region deployment
+
+**Languages**: Python (Advanced), GoLang (Advanced), Rust, C, JavaScript - Quick learner of new languages and frameworks
+
+**Backend Stack**: REST APIs, Redis, Elasticsearch, Docker, containerization, database design (SQLite, MySQL), encryption (RSA, AES)
+
+**Testing & Quality**: Pytest, RSpec patterns, TDD methodology, comprehensive test coverage, Factory Bot approach to test data
+
+**Infrastructure**: Kubernetes, AWS, GitLab CI/CD, Docker, cross-platform deployment, performance profiling and optimization
+
+**Methodologies**: High-autonomy ownership, end-to-end feature delivery, code review culture, architectural documentation (RFC/ADR), SCRUM
+
+# Education
+
+- **University of Maryland Baltimore Campus** - Masters in Computer Science (2013)
+  - Thesis: "Stateless Detection of Malicious Traffic: Emphasis on User Privacy"
+- **Salisbury University** - Bachelors in Computer Science (2009) - Magna Cum Laude
--- a/files/paul-halvorsen-files-backend-engineer.pdf
+++ b/files/paul-halvorsen-files-backend-engineer.pdf
--- a/paul-halvorsen-resume.pdf
+++ b/paul-halvorsen-resume.pdf
--- a/valon/paul-halvorsen-valon-cover-letter.md
+++ b/valon/paul-halvorsen-valon-cover-letter.md
@@ -0,0 +1,20 @@
+# Cover Letter: Paul Halvorsen — Software Engineer at Valon
+
+Dear Hiring Team,
+
+I'm writing to express my strong interest in the Software Engineer role at Valon. After following your work in fintech and regulated industries, I'm genuinely excited about the opportunity to contribute to ValonOS and help transform how the mortgage industry operates.
+
+Throughout my 15+ years as a backend engineer, I've spent most of my career building infrastructure for systems that require uncompromising reliability—the kind where failures cascade and impact customers directly. I've built distributed systems handling billions of events daily, engineered APIs serving Fortune 500 companies, and optimized systems that reduced resource consumption by 80-90%. But what excites me most about Valon isn't the scale problem itself—it's that you're solving it *within a regulated industry*. The complexity of federal, state, and agency requirements is a fundamentally different challenge than traditional tech, and that's exactly what I want to learn and master.
+
+What draws me to Valon specifically is your approach. Most companies try to bolt technology onto broken legacy systems. You built your own mortgage servicing business first—not as a feature, but as a way to deeply understand the problem space. That thinking resonates with me. I've always believed that understanding your domain completely is table stakes for building great software. Your transformation from 0% to 60%+ margins proves that philosophy works. And seeing a team from Stripe, Jane Street, Meta, and Google building something in fintech tells me you've recruited for both technical excellence and the ability to learn complex new domains.
+
+I'm confident I can succeed in this role. I learn quickly—I've worked across Python, Go, Rust, and C; built systems on Kubernetes, Docker, and GCP; and shipped complex features in distributed systems repeatedly. More importantly, I'm genuinely curious about regulated industries and excited to spend the next few years diving deep into mortgage servicing. I want to be part of a team that's rewriting the playbook for an entire industry.
+
+I'd love the opportunity to discuss how my background in building reliable, scalable infrastructure can contribute to Valon's mission.
+
+Thank you for considering my application.
+
+Warm regards,
+Paul Halvorsen
+paul.halvorsen@pm.me
+1-410-236-4665
--- a/valon/paul-halvorsen-valon-software-engineer.md
+++ b/valon/paul-halvorsen-valon-software-engineer.md
@@ -0,0 +1,75 @@
+---
+name: Paul Halvorsen
+keywords: software engineer, Python, Kubernetes, distributed systems, Google Cloud, Docker, system design, scalable infrastructure, fintech, API design
+left-column:
+    - 'Software Engineer'
+    - 'Email: [paul.halvorsen@pm.me](mailto:paul.halvorsen@pm.me)'
+    - 'Phone: +1-410-236-4665'
+right-column:
+    - 'LinkedIn: [www.linkedin.com/in/paul-halvorsen](www.linkedin.com/in/paul-halvorsen)'
+    - 'Git: [https://git.halvo.me/paul](https://git.halvo.me/paul)'
+    - 'Blog: [https://flow.halvo.me](https://flow.halvo.me)'
+---
+
+# Summary
+
+Full-stack engineer with 15+ years building systems at scale. Deep expertise in distributed systems, Python development, and building robust infrastructure for complex, regulated domains. Proven ability to learn new technologies and problem spaces quickly while maintaining code quality and system reliability. Experience designing and operating systems handling billions of dollars in transactions with zero tolerance for failure. Excited about solving hard problems at the intersection of technology and regulated industries.
+
+# Work Experience
+
+## Abnormal AI
+
+**Software Engineer**: Jan 2026 - Present (Remote)
+
+- **Large-Scale Infrastructure**: Architect and maintain 10 Kubernetes clusters across multiple regions (US East, US West, EU West, government) with auto-scaling and production-grade reliability requirements
+- **Python Microservices**: Build and maintain core data aggregation services handling real-time and long-term storage with comprehensive pytest coverage and unit testing throughout
+- **System Design & Operations**: Design systems that reliably serve multiple customers simultaneously with varying data requirements across geographies
+- **Performance & Reliability**: Implemented auto-scaling strategies and compression pipelines to increase efficiency and manage costs at scale
+- **Cross-functional Collaboration**: Work in tight team environment with heavy inter-team communication in monorepo structure; partner with infrastructure, backend, and product teams
+- **Ownership Model**: Own features end-to-end from design through deployment and monitoring
+
+## Binary Defense
+
+**Sr Software Engineer**: April 2022 - Oct 2025
+
+- **Distributed Event Processing at Scale**: Built systems serving Fortune 500 enterprise customers handling billions of events daily across thousands of endpoints
+- **Infrastructure & Reliability**: Deployed on Windows, Linux, and macOS with cross-platform testing and reliability as foundational requirement
+  - GitLab CI/CD pipelines for compilation, testing, and deployment
+  - Docker containerization for consistent reproducible builds
+- **Python Backend Development**: Designed and built multiple production services with focus on performance, reliability, and maintainability
+  - pytest-driven test suite ensuring confidence in changes
+  - Performance optimization: reduced CPU usage 90%, memory usage 60%, network traffic 80%
+  - Built data serialization and transformation pipelines for reliable backend communication
+- **System Design**: Engineered event-driven architectures handling filesystem, user, and network events with deterministic behavior
+- **Architecture & Standards**: Wrote RFCs and ADRs to drive technical decisions; contributed to code quality and documentation standards
+- **Complex Integrations**: Designed secure integrations with Azure and other third-party services
+- **Team**: Collaborated with experienced engineering team in SCRUM environment with strong code review practices
+
+## Kyrus Tech
+
+**Sr Software Engineer**: Nov 2020 - April 2022
+
+- **Distributed Systems**: Designed and built multi-layered distributed systems with REST APIs and complex routing logic
+- **Test-Driven Development**: Implemented comprehensive testing strategy using pytest; built infrastructure to enable confident, rapid deployments
+- **Python & Docker**: Built containerized services leveraging Docker for reproducible deployments
+- **Low-Level Systems**: Worked on performance-critical code including reverse engineering and systems analysis
+
+# Technical Skills
+
+**Languages**: Python (Advanced), GoLang, Rust, C, JavaScript
+
+**Infrastructure & Cloud**: Kubernetes (10+ production clusters), Google Cloud Platform (GCP), Docker, containerization, system design, microservices architecture
+
+**Backend Development**: REST APIs, distributed systems design, database design (SQLite, MySQL), event-driven architecture, scalable data pipelines
+
+**Testing & Quality**: pytest, test-driven development (TDD), comprehensive unit and integration testing, code review culture
+
+**DevOps & Tools**: GitLab CI/CD, Docker, Kubernetes, monitoring, logging, performance profiling
+
+**Soft Skills**: Quick learner, cross-functional collaboration, autonomy, code quality focus, rapid iteration
+
+# Education
+
+- **University of Maryland Baltimore Campus** - Masters in Computer Science (2013)
+  - Research in distributed systems and network security
+- **Salisbury University** - Bachelors in Computer Science (2009) - Magna Cum Laude
--- a/valon/paul-halvorsen-valon-software-engineer.pdf
+++ b/valon/paul-halvorsen-valon-software-engineer.pdf