Independent Consultant
Building Scalable Systems,
Automation Tools,
and AI‑Driven Workflows
Seasoned software engineer and consultant specializing in scalable backend systems, cloud architecture, and modern web applications.
Focused on reliability, performance, and real-world production systems.
About
The person behind Tunetips
I'm a technical lead and independent consultant with more than 9 years of experience. Tunetips is my personal brand — not a company. Just a hands-on engineer who builds systems for real production environments.
I've spent years working across the full stack: designing backend systems in .NET, architecting cloud infrastructure on Azure, and building frontend applications in Angular and React. The common thread is a focus on systems that actually work under pressure.
I design and build systems that run reliably in production — not just prototypes.
TimeSnap is my current product — built solo, from system design through deployment.
What I bring
- Hands-on experience building production APIs and distributed systems
- Deep background in Azure Functions, Queues, and cloud-native architecture
- Concurrency handling and system reliability engineering
- Strong frontend capability in Angular and React
- AI workflow integration that actually serves business needs
Stack
Expertise
Core engineering capabilities
Five areas where I spend most of my time — each grounded in production experience.
Backend Engineering
Modern .NET Core development with a focus on API design, performance optimization, and maintainable service architecture.
- .NET Core APIs, Web API, and microservice-based architecture
- High-throughput request handling and optimization
- Background processing and job scheduling
- Performance profiling, PDF generation, tuning, and file processing
Cloud Architecture
Azure-native solutions built for reliability — Functions, Storage, Queues, and Key Vault wired together with care.
- Azure Functions and event-driven design
- Queues, background processing, and concurrency handling
- Managed Identity, Key Vault for secrets, environment-based overrides
- Cost-conscious and secure infrastructure design
Frontend Systems
Scalable Angular and React applications built to work with complex backends — not just display data.
- Angular and React architecture
- Structured HTTP request wrappers and state handling
- API integration and error handling
- Component systems and design tokens
- RxJS patterns and observable-based data flows
System Design
Distributed system design with real production constraints — concurrency, failure modes, and operational visibility.
- Distributed systems and concurrency handling
- Agile practices and software process engineering
- Code review culture and quality standards
- Layered architecture and application design
- Observability and structured logging
AI & Agentic Development
AI integrated where it adds real value — automating repetitive workflows, enhancing decision logic, and augmenting backend processes.
- AI-powered workflow automation
- Agentic task orchestration in backend systems
- LLM integration into production APIs
- AI-assisted business process design
Featured Product
A secure, Forge-powered Jira Cloud app that makes time tracking effortless. Built for teams who need a simple, reliable, and configurable solution — without the complexity of enterprise tooling.
TimeSnap runs entirely on Atlassian's infrastructure via the Forge platform. There are no external servers — your data never leaves your Jira instance. I designed and built it end-to-end: data model, API layer, admin configuration, and the Custom UI frontend.
Stack
TimeSnap for Jira
Smart time tracking & worklog insights
Platform
Jira Cloud
Runtime
Atlassian Forge
Version
3.7.0
Role
Full design + build
Fast worklog entry & review
Log time against Jira issues quickly. Review worklogs per issue or per user without leaving your workflow.
Time reports with XLSX export
Detailed time reports that can be exported to Excel — ready for billing, payroll, or project reviews.
Flexible admin configuration
Teams can customise settings to match how they work. Configuration is built into the app, not bolted on.
Secure Atlassian infrastructure
Built on Forge — data stays within Atlassian's infrastructure. No external servers, no data leaving your instance.
Engineering Work
Real problems, real solutions
Architecture and system design problems I've worked through in production.
Problem
PDF Compression in .NET Core
Large PDFs were causing slow uploads and email delivery failures. The system needed server-side compression without quality loss.
Approach
Combined iText7 for reading and navigating PDF structure with ImageSharp for image resizing and re-encoding. Used SemaphoreSlim to limit concurrent compression jobs and prevent memory spikes.
Outcome
Achieved 20–30%+ file size reduction while preserving readability across all tested documents.
Problem
Handling High Request Loads
A reporting API serving thousands of concurrent users was degrading under load.
Approach
Redesigned the data access layer with async streaming, added response caching at the service layer, and introduced rate limiting with queue-based overflow handling.
Outcome
Reduced P99 latency by 70% under sustained load.
Problem
Queue-Based PDF Generation
On-demand PDF generation was blocking web requests and causing timeouts for large documents.
Approach
Moved generation to an Azure Functions background worker triggered via Storage Queue. Added a polling endpoint so clients get a job ID and check status asynchronously.
Outcome
Zero timeouts. Generation scales independently of the API tier.
Problem
Structured HTTP Request Wrapper in Angular
An Angular application was making inconsistent API calls with scattered error handling and no shared loading or state persistence logic.
Approach
Built a typed HTTP request wrapper service managing request state, loading flags, error handling, and response caching in a single reusable layer. PATCH support included for partial updates.
Outcome
Consistent API interaction across the app. Reduced duplicated error handling code significantly.
Problem
Web API Authorization in ASP.NET Core
A multi-tenant API needed fine-grained access control beyond simple role checks — including scope-level and data-level authorization.
Approach
Implemented policy-based authorization, scope-level access via claims, role-based guards, and action filters for data-level filtering. Structured around ASP.NET Core's filter pipeline.
Outcome
Clean, layered authorization that handled all business scenarios without scattered permission checks across controllers.
Blog
Engineering thinking
Real decisions, tradeoffs, and lessons from production systems.
Configuration Management in .NET Core: Web API and Azure Functions
How to manage configuration consistently across Web API and Azure Functions — JSON files, environment variables, and Key Vault in one unified approach.
Implementing PDF Compression in .NET Core Using iText7 and ImageSharp
A practical walkthrough of server-side PDF compression — why iText7 and ImageSharp, how they work together, and how to handle concurrency safely.
Structured HTTP Request Wrapper in Angular: Managing State Persistence
How to build a reusable Angular HTTP wrapper that handles loading state, error handling, and partial updates cleanly across your application.
Work Philosophy
How I think about engineering
Reliability over hype
Production systems need to survive real conditions — partial failures, spikes, bad data. That's where the hard work happens.
Simplicity over over-engineering
Every abstraction has a cost. I default to the simplest thing that works in production and add complexity only when the system earns it.
Systems that survive
Good software doesn't just launch — it runs for years. That means observable, maintainable, and operable from day one.
AI where it earns its place
AI is useful. It's also often unnecessary. I integrate it where it solves a real problem, not because it's expected.
Contact
Let's build something
reliable.
Available for consulting engagements, architecture reviews, and backend systems work. If you have a real problem, I'm interested in hearing about it.