Backend Engineering • Architecture • Infrastructure • Go • Python/Django • Media Systems
I’m a hands-on technical leader and software engineer focused on building and operating reliable backend systems.
My background spans frontend development, full-stack engineering, backend architecture, infrastructure, CI/CD, and technical leadership. I have worked both as an individual contributor and as a CTO, and I prefer roles where I can stay close to the engineering work while owning technical direction.
I’m particularly interested in backend systems, Go, architecture, infrastructure, reliability, DevOps, and technically demanding products.
I started my career in frontend development and gradually moved toward backend engineering after realizing I wanted to understand and own more of the systems behind the products I was building.
Today, my work is primarily focused on:
- Designing backend and system architectures
- Building production services with Go and Python/Django
- Designing APIs and data models
- Building infrastructure and deployment systems
- Designing CI/CD pipelines
- Working with databases and distributed/background processing
- Building video and media-processing systems
- Making technical decisions and evaluating engineering trade-offs
- Leading engineering teams while remaining hands-on
I enjoy taking ownership of difficult technical problems and learning whatever is necessary to solve them properly.
- Go
- Python / Django
- REST APIs
- gRPC
- SQL
- OpenAPI
- Background processing
- Concurrent systems
- Distributed systems
- Modular monoliths
- Microservices
- Package / plugin architectures
- TypeScript
- JavaScript
- React
- Next.js
- Vue.js / Nuxt.js
- Tailwind CSS
- State management
- React Hook Form
- SSR / SSG when appropriate
I started with JavaScript and moved to TypeScript early in my career. I primarily use React today.
- PostgreSQL
- Redis
- Valkey
- SQLite
- MongoDB
- Database schema design
- Indexing
- Query optimization
- Transactions
- Migrations
- Connection pooling
- Backup & recovery
- Caching
- Linux
- Docker
- Docker Compose
- Nginx
- Load balancers
- Reverse proxies
- VPS infrastructure
- Object storage
- NFS
- CDN
- SSL/TLS
- Monitoring
- Logging
- Backups
- Database deployment
I have personally designed and maintained CI/CD pipelines using:
- GitLab CI/CD
- GitHub Actions
- Automated testing
- Vulnerability checks
- Docker image builds
- Staging deployments
- Production deployments
- Database migrations
- Health checks
- Manual production approval
- Rollback workflows
- Environment separation
I care about making deployments repeatable, observable, and recoverable rather than relying on manual server operations.
One of my strongest areas is video and media infrastructure.
I have worked with:
- FFmpeg
- Video transcoding
- Multiple resolutions
- HLS
- DASH
- Multi-audio processing
- Subtitle processing
- AI-generated subtitles
- Video metadata
- Thumbnail generation
- Timeline thumbnails
- Large-file uploads
- Chunked uploads
- Resumable uploads
- Upload recovery
- Object storage
- NFS
- CDN delivery
- Video streaming
My AI experience is primarily focused on integrating models into production systems rather than purely researching machine learning.
I've worked with:
- Whisper
- Model fine-tuning
- Speech-to-text
- Multilingual subtitle generation
- LLM-based translation pipelines
- Background AI processing
- Self-hosted AI services
- gRPC communication between AI services
I've worked with different architectural approaches depending on the problem:
Monolith
│
├── Modular Monolith
│
├── Package / Plugin Architecture
│
├── Microservices
│
└── gRPC Services
I don't believe architecture should be selected because a particular pattern is fashionable.
A simple monolith can be the right solution.
A modular monolith can be the right solution.
A service-oriented architecture can be the right solution.
The important part is understanding the trade-offs and choosing an architecture that the team can actually operate and evolve.
I don't want technical leadership to separate me completely from implementation.
I enjoy designing systems, but I also want to understand how those systems actually behave in production.
I try to avoid introducing complexity without a reason.
At the same time, I have learned an important lesson from my own mistakes: over-engineering can be just as damaging as under-engineering.
I now pay much more attention to scope, delivery speed, and what the system actually needs today.
If developers repeatedly perform the same manual operation, there is probably an opportunity to automate it.
I've built automation around:
- Deployments
- Testing
- Media processing
- Background jobs
- Developer workflows
- Database operations
- AI processing
- Project scaffolding
I prefer systems that are:
- Predictable
- Observable
- Recoverable
- Testable
- Easy to deploy
- Easy to debug
A system doesn't become reliable because it has a complicated architecture.
It becomes reliable because its failure modes are understood and handled.
I've worked as a CTO and technical lead while remaining substantially hands-on.
My leadership responsibilities have included:
- Hiring engineers
- Managing engineering teams
- Managing Heads of Engineering
- Architecture ownership
- Technical strategy
- Code review
- Pull request review
- Engineering standards
- Development planning
- Technical estimation
- Feasibility analysis
- Technology selection
- Build-vs-buy decisions
- Infrastructure ownership
- CI/CD architecture
- Translating business requirements into engineering decisions
- Communicating technical trade-offs to company leadership
I have also established engineering standards around:
- Code review
- Branch strategy
- Commit conventions
- Testing
- API standards
- Documentation
- Linting
- Type checking
- Formatting
- CI requirements
- Definition of Done
I prefer technical leadership that remains connected to implementation.
Some areas I've worked on in production include:
- Backend systems serving large user populations
- High-volume educational content platforms
- Large video libraries
- Hundreds of concurrent video viewers
- Multi-terabyte storage systems
- Large-file upload infrastructure
- Asynchronous processing pipelines
- AI-assisted media processing
- PostgreSQL optimization
- Authentication and authorization systems
- Production CI/CD
- Containerized deployments
- CDN-based media delivery
- Infrastructure and server management
I've also worked on smaller systems where the goal was simply to eliminate repetitive work, reduce errors, or provide developers with better tooling.
I enjoy both ends of the spectrum.
I'm especially interested in:
- Backend services
- Go services
- Platform infrastructure
- Developer tooling
- CI/CD systems
- Distributed processing
- Media processing
- Video infrastructure
- API platforms
- Internal engineering tools
- Reusable software architecture
My current technical direction is increasingly centered around:
Go → Backend Systems → Infrastructure → Reliability → Architecture → Technical Strategy
I'm continuing to deepen my Go experience while keeping Python/Django as a second part of my backend toolkit.
For AI-heavy systems, I still prefer Python where its ecosystem provides a clear advantage.
I want to work on a large product with a serious engineering team.
The environment I'm looking for is one where I can:
- Own backend architecture
- Work on infrastructure
- Make meaningful technical decisions
- Improve reliability and deployment
- Solve difficult engineering problems
- Stay hands-on with code
- Learn from strong engineers
- Help other engineers grow
I'm particularly interested in products where backend, platform, infrastructure, or media-processing problems are important to the product.