Backend & application
Services, APIs, and the workflows behind them.
- Java 11–21
- Spring Boot
- Spring Data JPA
- JDBC
- REST APIs
Software engineering portfolio
Nithiwut Wilainuch
Senior Software Engineer
Backend-focused software engineer with 6 years of experience building production systems across banking and startup environments.
My work spans application code, data, asynchronous processing, cloud infrastructure, and the day-to-day realities of running software in production.
Bangkok, Thailand
Engineering areas
The areas I work in, and the tools I’ve used along the way.
Data & performance
Relational data access, caching, and search.
- PostgreSQL
- MySQL
- Redis
- Elasticsearch
Async & event-driven
Background jobs and event-triggered processing.
- AWS SQS
- Lambda
- S3
- EventBridge
Production & observability
Application logs and production troubleshooting.
- Kubernetes
- Logstash
- Elasticsearch
- Kibana
Delivery & infrastructure
Application deployment and release workflows.
- Docker
- Kubernetes
- Helm
- GitLab CI/CD
- Jenkins
- Terraform
- AWS
Additional experience
Web applications and supporting services.
- Python
- TypeScript
- NestJS
- Angular
- React
- Next.js
Selected engineering work
A closer look at production problems and the decisions behind the implementation.
Featured project · Backend architecture
WealthHub
An investment portfolio backend built around a transaction ledger, weighted average cost, consistent holdings, and explicit valuation states.
Persistence / performance
High-volume database processing
- Context
- A backend workflow relied on repetitive JPA operations for high-volume persistence, adding unnecessary ORM overhead to the processing path.
- Approach
- Refactored the high-volume path to use explicit JDBC bulk operations, while keeping the change focused on the workload that needed it.
- Why this approach
- JPA remains useful for general application persistence, but repetitive high-volume operations benefit from more explicit control over batching and SQL execution. JDBC was applied specifically to the workload that needed it rather than replacing JPA across the application.
- Outcome
- Reduced ORM overhead on the high-volume persistence path and made bulk database operations more explicit and appropriate for the workload.
- Engineering considerations
- The access pattern matters as much as the abstraction. Bulk operations address repetitive persistence work; explicit SQL also brings more responsibility for maintaining that path.
- Spring Boot
- JDBC Bulk Operations
- PostgreSQL
Background workloads / queues
Asynchronous export processing
- Context
- Large report and data exports take longer than a typical API request should remain open.
- Approach
- Used AWS SQS to queue export work for background workers, separating processing from the HTTP request-response lifecycle.
- Why this approach
- Export generation can outlive a normal HTTP request. Queueing the work through SQS separates request acceptance from processing and avoids keeping the request open while the export is generated.
- Outcome
- Moved long-running export processing outside the HTTP request lifecycle, allowing the API request and background processing to be handled independently.
- Engineering considerations
- Accepting a request and completing an export are separate events. The workflow needs a clear way to represent the result and its processing status.
- Client / API
- AWS SQS
- Worker
- Result / status
Media processing / AWS
Event-driven image optimization
- Context
- Original vehicle images are larger than necessary for many marketplace views, adding avoidable bandwidth to image delivery.
- Approach
- Used S3 upload events to trigger Lambda processing that resizes images and creates WebP variants.
- Why this approach
- Image transformation does not need to block the upload flow. Triggering processing from the uploaded object keeps resizing outside the main request path while allowing reusable image variants to be generated independently.
- Outcome
- Produced resized WebP image variants after upload without adding image transformation work to the main request path.
- Engineering considerations
- Processing after upload keeps transformation out of the main request path. Reusable, presentation-ready variants make image delivery more efficient.
- Upload to S3
- S3 event
- Lambda
- Resize / WebP
Further engineering notes
Production & observability
Hands-on production support includes searching and filtering centralized application logs, investigating Kubernetes application and deployment issues, and tracing failures toward a root cause.
- Application
- Logstash
- Elasticsearch
- Kibana
Java 11 → 21
Upgraded backend services from Java 11 to Java 21, adopting modern language features such as records where appropriate. The work combined a platform upgrade with focused changes to application code.
Professional experience
Apr 2023 – Present
Currentttb bank
Senior Software Engineer
Backend engineering for the Roddonjai used-car marketplace and lead generation platforms in a banking environment.
- Develop services supporting seller onboarding, inspections, listings, campaigns, and internal operations.
- Co-develop lead generation systems with vendor teams and contribute to an internal Angular and NestJS implementation.
- Contribute to technical design, code reviews, delivery planning, and production support.
May 2021 – Mar 2023
Purple Ventures
Software Engineer
Production backend services built with Java, Python, and AWS Serverless in a startup environment.
- Built Lambda-based APIs, background workflows, promotion verification, and automated reporting services.
- Replaced manual ZIP deployments with Docker and Jenkins delivery pipelines.
- Investigated production issues with engineering and data teams.
Jun 2020 – Apr 2021
Institute of Public Policy and Development
Backend Developer
Public-policy applications and data workflows, with experience across backend and web development.
- Developed Django and PostgreSQL services and REST APIs.
- Built React and Next.js interfaces and maintained ETL and data pipelines.
How I work
Understand before optimizing
Start by locating the bottleneck: application logic, database access, an external dependency, or infrastructure. Let the problem guide the change.
Design with failure in mind
Ask what happens when work fails halfway through. Consider transaction boundaries, retries, and whether repeating an operation is safe.
Own beyond the code
Consider how a change will be deployed, observed, and debugged in production, and how someone else will maintain it later.
Education
Chulalongkorn University
Bachelor of Engineering (Computer Engineering)
Senior project: License Plate Recognition Using Deep Learning
YOLO transfer learning with Python and Keras; containerized deployment to Google Cloud Run.