A&A
Ashan
Ashan Working 1
Introduction

ASHAN
DHANUSHKA

Cloud · Full-Stack · AI/ML · System Administration

Colombo District, Western Province, Sri Lanka

PROJECTS

A portfolio of engineering excellence across multiple domains.

Programming Languages & Developer Tooling

Sloperator: SlopLang Tree-Walking Interpreter

Python 3.13 · Lexer · Parser · Evaluator · Pytest · Ruff · ty

A complete tree-walking interpreter for SlopLang, a deliberately unconventional language built around emoji terminators, smart quotes and words like slop, loadbearing and clanker. The Python 3.13 implementation takes UTF-8 source through a lexer, recursive-descent parser and lexical-scope evaluator, then exposes it through a CLI, a --check mode and a browser playground. A formal language specification anchors the behavior, while 195 Pytest cases and Ruff/ty quality gates keep the implementation honest.

Key Learning Points:
Three-stage execution pipeline: a UTF-8 lexer, recursive-descent parser and tree-walking evaluator with source-line diagnostics for lexical, syntax and runtime errors.
Lexical runtime model: nested environments, shadowing, call frames, mutable slop versus immutable loadbearing bindings, exact argument arity and a 500-call stack-overflow guard.
No-coercion semantics: booleans stay distinct from numbers, + adds numbers or concatenates strings, division truncates toward zero, and && / || short-circuit after strict boolean checks.
Functions as first-class values: named top-level clankers, parameter/local scoping, ship unwinding nested blocks and loops, function equality and mutual recursion.
Developer tooling: a sloperator.py CLI with file execution and --check, a browser playground, a formal spec and a regression suite covering scope, compound assignment, recursion, operators and error messages.
Quality pipeline: 195 Pytest cases plus Ruff formatting/linting and ty type checking, all run through uv for a reproducible Python 3.13 workflow.
Python 3.13InterpreterLexerParserTree-Walking EvaluatorLanguage DesignPytestRufftyCLIPlayground
Repository
AI Coding with OpenCode · Boot.dev
Cloud Storage, CDN & Media Engineering

Tubely: S3-Backed Video Platform

Bun · TypeScript · SQLite · AWS S3 · FFmpeg · Presigned URLs

A production-style video hosting backend built on Bun and TypeScript. Tubely accepts MP4 uploads up to 1 GB, validates and fingerprints each file with ffprobe, rewrites the container for instant playback with FFmpeg faststart, and stores assets in S3 under aspect-ratio-aware keys. A JWT/Argon2 auth layer, refresh-token rotation, SQLite persistence and short-lived presigned URLs keep private media off the public internet while still enabling direct browser playback.

Key Learning Points:
Direct-to-storage media intake: 1 GB MP4 uploads with MIME/size validation and S3 keys partitioned by landscape, portrait or other from ffprobe dimensions.
Instant-play transcoding: FFmpeg faststart rewrites the moov atom with stream copy, so playback starts before the full file downloads and no re-encode is needed.
Private-by-default delivery: 15-minute S3 presigned URLs generated per request, with existing signed URLs detected and reused.
Identity and session security: Argon2 password hashing, short-lived JWT access tokens and rotating refresh tokens persisted in SQLite.
CDN-ready architecture: S3 origin plus CloudFront distribution configuration for edge delivery of media assets.
Operational hygiene: temporary-file cleanup in finally blocks, strict upload limits and explicit API error mapping.
BunTypeScriptAWS S3CloudFrontFFmpegSQLiteJWTArgon2Presigned URLsVideo Streaming
Respective Repositories:
tubely
Repository
Kubernetes & Cloud-Native Operations

Kubernetes Multi-Tier Chat Platform

Minikube · Deployments · Gateway API · HPA · ConfigMaps · PVC

A hands-on Kubernetes deployment of a multi-service chat platform on Minikube. The stack separates web, API and crawler workloads across namespaces, injects runtime configuration through ConfigMaps, persists crawler state on a PVC, and exposes services through the Kubernetes Gateway API with HTTPRoutes. A HorizontalPodAutoscaler scales the web tier on CPU, while resource requests and limits plus multi-container crawler pods demonstrate production-shaped scheduling and debugging.

Key Learning Points:
Gateway API routing: GatewayClass, Gateway and HTTPRoute objects replace legacy Ingress for host and path-based traffic.
Autoscaling: a HorizontalPodAutoscaler watches the web Deployment and scales from 1 to 4 replicas at 50% CPU utilisation.
Configuration separation: ConfigMaps feed API_URL, ports and crawler keywords into pods without rebuilding images.
Stateful workloads: a 1 Gi ReadWriteOnce PVC mounted at /cache across a three-container crawler pod, so CRAWLER_DB_PATH survives restarts.
Namespace isolation: crawler workloads run in a dedicated namespace, separate from the web and API tier.
Operational debugging: resource limits, service selectors, pod-level troubleshooting and repeatable kubectl workflows.
KubernetesMinikubeGateway APIHTTPRouteHPAConfigMapsPVCDockerLinuxkubectl
Respective Repositories:
kubernetes-synergychat
Repository
Learn Kubernetes · Boot.dev
Dockerized 3-Tier Platforms

GradeVault: Parent–Teacher Academic Vault

Next.js · Spring Boot · PostgreSQL · Nginx · Docker Compose

A containerized parent–teacher portal that keeps academic records behind a hardened network boundary. Nginx is the only public entry point; the Next.js frontend runs two replicas on a public bridge, while Spring Boot and PostgreSQL live on an internal-only network. Health-checked dependencies, named volumes and restart policies make the stack reproducible with one docker compose up, and an analytics sidecar adds forecasting over the academic data.

Key Learning Points:
Network segmentation: the secure-vault-tier is internal-only, so the database has no route to the public network.
Reverse-proxy boundary: Nginx fronts both app tiers and is the sole published port.
Reproducible multi-service stack: health-checked Postgres, two frontend replicas, two backend replicas and restart policies.
Security fixes: added CORS configuration and environment-aware datasource settings after a documented issue review.
Operational readiness: container health checks, depends_on conditions and a persistent Postgres volume.
Analytics extension: a Python forecasting service reads academic data for parent and teacher insight.
Docker ComposeNext.jsSpring BootPostgreSQLNginxSpring SecurityHealthchecksPython Analytics
Respective Repositories:
parent-teacher-platform
Repository
UI/UX Design & Prototyping

PT Client Manager: Personal-Trainer Companion App

Single-File React Prototype · Mobile-First UI · Light & Dark Themes

An interface designed for a real person to admire — Coach Asanka Armstrong, an owner-operator personal trainer in Colombo. The core brief was a one-glance daily schedule; the result is a fully working, single-file responsive web app that adds client roster management, a workout library, nutrition logging and BMI/body-fat history. Built on Jakob Nielsen's ten usability heuristics, Shneiderman's Eight Golden Rules and colour-blind-friendly design, then refined through an honest-feedback pass and a pilot usability test.

Key Learning Points:
User-first design: shaped every decision around one real trainer's daily reality — phone-based, between-sessions, fast logging, no time for paperwork.
Design theory applied: status pills carry icon + label + colour, all five destinations stay visible (recognition over recall), and colour is never the only signal.
Atomic design system: Pill, Bar, Sparkline, Toggle, IconBtn and StatusChip atoms combined into StatCard, ClientCard, MealRow and ChartCard molecules on an 8pt grid.
Consistent shell: a desktop sidebar and a mobile bottom navigation bar keep the same five screens reachable with one thumb.
Working prototype: one self-contained HTML file (React, no build step) behaving like the final system — dual-line weight/body-fat chart, calorie ring and live BMI/Body-Fat/muscle-mass calculations.
Evaluation & iteration: fifteen-plus usability attributes tested in a pilot run, fixing a double-firing theme toggle, colliding SVG gradient IDs, and a modal that became a mobile bottom sheet.
Process: throw-away paper wireframes in Balsamiq, high-fidelity components and tokens in Figma, pattern research in Mobbin and hand-off in Zeplin.
UI/UX DesignReactHTML/CSSResponsive DesignDark ModeDesign SystemAccessibilityPrototypingData VisualizationWireframing
Repository
Design Documentation Live Demo
Full-Stack Enterprise Systems

Applebay LMS: Academic, Attendance & Fee Management

Next.js 14 · Spring Boot 3.3 (Java 21) · PostgreSQL (Neon) · Spring Data JPA

A production-grade learning management system engineered for cohorts of 350–400 students across HND and certificate tracks. Architected across decoupled repositories with an atomic layered Spring Boot REST backend on Render and a high-performance Next.js 14 client on Netlify. Features sequential student and receipt numbering, atomic enrollment-payment transactions, dynamic fee balance derivation with pessimistic locking, bulk attendance reconciliation with 80% exam eligibility reporting, and role-based JWT security with instantaneous tokenVersion revocation.

Key Learning Points:
Decoupled Production Architecture: Backend deployed on Render (REST API, Flyway migrations, Actuator health) and Frontend static export on Netlify with custom security headers and CSP.
Atomic Registration Pipeline: Student provisioning, sequential ID generation (AB2026-xxxx), batch enrollment with duplicate checks, and first payment commit as a unified transactional unit.
Concurrency-Safe Fee Ledger: Real-time balance derivation under pessimistic write locks, supporting backdated audits and strictly rejecting overpayments with HTTP 422.
Bulk Attendance Engine: Upserts class-wide sheets in a single payload, tracks on-the-fly corrections, and computes strict 80% exam eligibility thresholds.
Enterprise Security Hardening: Role-based JWT authentication with tokenVersion revocation, rate-limited login endpoints, automated account lockout protection, and audit logging.
Normalized 3NF Data Layer: Composite unique keys on enrollment batches and attendance sessions, backed by sequence-driven receipt numbering (RC2026-xxxxxx).
Defensive API Contract: Bean Validation, paginated search queries, comprehensive Mockito test coverage, and global exception mapping for uniform JSON error responses.
Next.js 14Spring Boot 3.3Java 21PostgreSQL (Neon)Spring Data JPAFlywayJWT AuthOWASP HardeningTailwind CSSMockito
Respective Repositories:
applebay-backendapplebay-frontend
Live Admin Access CredentialsRole: SUPER_ADMIN
Emailadmin@applebay.local
PasswordNewAdmin!2026Strong
Repository
Technical Documentation Live Demo
Cloud Architecture & DevOps

3-Tier ERP on Kubernetes with Northflank

Northflank · Kubernetes · Docker · Next.js 14 · PostgreSQL

A classic AWS 3-tier architecture — web tier, app tier and an isolated database tier behind a load balancer with an IP allowlist standing in for the office VPN — rebuilt for free on Northflank, a Kubernetes-backed PaaS. Two instances per service behind an Envoy proxy, infrastructure created by a re-runnable Bash script against the Northflank API, and a full-stack Next.js 14 + Auth.js + Prisma + PostgreSQL user-management app deployed on it, then load-tested, latency-profiled and security-probed from Colombo.

Key Learning Points:
Three tiers in one project: public web service, private app service and a managed PostgreSQL database with no public endpoint, provisioned by a safe-to-re-run Bash script calling the Northflank API.
Redundancy: 2 instances per service behind an Envoy proxy — 60 requests split 35/25 across the two pods.
Latency & throughput: ~267 ms TCP connect from Colombo to London (mostly distance) and ~262 req/s at 100 concurrent users on a very small free plan.
Security audit: valid TLS 1.2/1.3 with HTTPS redirects, but missing security headers and rate limiting — then fixed in the app config.
The app: register, log in and a dashboard of all registered users, with update and delete scoped to the user's own account.
Tooling lesson: ab reported thousands of "failed" requests that were really just varying response lengths.
NorthflankKubernetesDockerNext.js 14Auth.jsPrismaPostgreSQLBashabwrk
Respective Repositories:
kubernetes
Repository
Portfolio Post Live Demo
Cloud Architecture & Microservices

3-Tier Enterprise ERP Architecture

Next.js · Spring Boot · PostgreSQL · LocalStack

An enterprise-grade 3-tier ERP architecture designed for isolated multi-AZ deployment. Features end-to-end BCrypt authentication, Spring Data JPA connection pooling, Next.js dynamic user dash, and stress-tested throughput reaching ~500 TPS under concurrent load.

Key Learning Points:
3-Tier Perimeter Isolation: Segregated Public, App, and isolated DB subnets across 2 AZs.
High-Concurrency Benchmarking: Profiled HikariCP connection pools and Tomcat threads with wrk at ~500 TPS.
Cryptographic Auth Pipeline: BCrypt password hashing with CORS-hardened Spring Security filters.
LocalStack Cloud Verification: Simulated dual ALBs, VPC routing, and Secrets Manager integration locally.
Spring BootNext.jsPostgreSQLDockerLocalStackwrkJava 17
Respective Repositories:
erp-demo-backenderp-demo-frontend
Repository
Systems Programming & Performance

Slim-Pack: Rust Serialization Engine

Binary Serialization · Schema-Driven Design · Performance Engineering

A Rust-first binary serialization prototype for telemetry and structured records, focusing on schema-driven encoding, compact fixed layouts, dynamic value handling, and a CLI for inspecting layouts from schema files. Optimized the JSON hot path using a fast-path parser and reduced UTF-8 boundary overhead, delivering measurable improvements on real benchmark datasets versus serde_json.

Key Learning Points:
Systems-Level Rust Engineering: Built core codec with safety guards, derive support, and CLI schema inspection tooling.
Schema-First API Design: Implemented schema-driven encoding with compact fixed layouts and dynamic value handling.
Performance-Focused Optimization: Optimized the JSON hot path with fast-path parsing and reduced UTF-8 boundary overhead.
Benchmark-Driven Engineering: Validated improvements on real benchmark datasets with tests, property checks, and real-world data.
Correctness & Safety: Maintained edge-case validation while delivering measurable performance gains over serde_json.
RustSerializationBinary ProtocolsPerformance EngineeringBenchmarkingSystems ProgrammingCLI ToolingSchema-Driven Design
Respective Repositories:
slim-pack
Repository
Real-Time Systems & AI Telemetry

Real-Time AI Telemetry Pipeline

TypeScript · Node.js · Protobuf · WebSockets

A real-time AI telemetry system that simulates an edge-device camera stream sending serialized frame data to an AI agent, which processes the payload and returns detection telemetry such as object labels, confidence scores, and bounding box metadata. Demonstrates a practical event-driven architecture for machine-vision pipelines, where binary serialization is used for efficient communication between components.

Key Learning Points:
Protobuf Schema Design: Defined ai.agent messages for camera frames and AI responses - VisionFramePacket, DetectedObject, and AgentTelemetry.
Binary Serialization: Encoded raw frame bytes and detection metadata on the wire instead of JSON, keeping streaming payloads compact.
WebSocket Telemetry Server: Decodes inbound messages asynchronously and generates detection responses with processing-latency measurement.
Client Simulator: Sends synthetic frame data at a steady rate to exercise the pipeline end-to-end without real hardware.
Live Monitoring Dashboard: Web dashboard for observing system activity and streamed detections in real time.
JSONL Telemetry Logging: Appends newline-delimited JSON records for traceability and downstream analysis.
Extensible Foundation: Structured to later support real image recognition models, multi-camera processing, and production monitoring.
TypeScriptNode.jsProtobufWebSocketsJSONLReal-Time StreamingEdge AIObservability
Respective Repositories:
agent-protobuf-stream
Repository
Project Report 
Developer Tools & VS Code Extension

Knight Rider KITT 2.2.0

AI Coding Assistant for VS Code · Streaming Chat & Workspace Context

A renamed and reworked release of my VS Code AI assistant. Version 2.2.0 targets the editor hangs that made the extension unusable on large workspaces and in Codespaces, fixing five separate causes: unscoped diagnostics, leaked open documents, unbounded file reads, an unnecessary workspace index build, and an un-debounced mention picker.

Key Learning Points:
Scoped Diagnostics: Collected errors and warnings for the active document only, instead of requesting every open file and filtering afterwards.
Bounded File Reads: Switched context loading to workspace.fs.readFile() so files no longer enter the editor document model, skipping anything over 512 KB or containing NUL bytes.
Lazy Indexing: Deferred the recursive findFiles() index build until a request actually needs it for @mentions or auto-context.
Debounced Autocomplete: Coalesced @mention queries at 180 ms and dropped stale responses that arrived out of order.
Safe Credential Storage: Kept API keys in VS Code SecretStorage so they never reach settings.json or a webview context.
Test Harness Hardening: Extended the vscode stub with an instrumented fs, diagnostics, and findFiles to assert the above, growing the suite from 166 to 181 assertions.
TypeScriptVS Code APINode.jsStreaming LLMSecretStoragejsdom
Respective Repositories:
nightrider-copilot
Repository
Documentation 
Cloud & DevOps Engineering

Signal: Cloud Media Ingestion Pipeline

Event-Driven Media Processing & Transcoding

Asynchronous cloud-native media processing pipeline with automated S3 intake, SQS message queuing, security validation, and HLS transcoding backed by a PostgreSQL metadata store.

Key Learning Points:
Event-driven architecture using S3 event notifications and SQS queues
Cloud environment emulation with LocalStack for local microservice testing
Asynchronous video transcoding and adaptive bitrate (HLS) generation
Relational asset metadata tracking and pipeline state management in PostgreSQL
LocalStackAWS S3AWS SQSPostgreSQLFFmpegDockerReact
Respective Repositories:
Automated-Cloud-Media-Ingestion-Pipeline
Repository
Fintech & Blockchain

CBDC Credit Underwriting Terminal

Basel III "5 Cs of Credit" Risk Engine · Next.js · Bun · Supabase · Cloudflare Workers AI

An institutional-grade CBDC credit underwriting terminal that evaluates sovereign digital asset solvency using the international Basel III "5 Cs of Credit" framework. Built with Next.js, Bun, and Supabase PostgreSQL via transaction-mode connection pooling, the system delivers real-time risk trajectory visualizations and immutable ledger audits. Credit clearance decisions are synthesized in under two seconds at the edge via Cloudflare Workers AI running quantized Meta Llama 3.2 models with zero external data leakage.

Key Learning Points:
Basel III Credit Risk: Underwriting sovereign digital asset solvency against the international "5 Cs of Credit" framework (Character, Capacity, Capital, Collateral, Conditions).
Edge AI Inference: Sub-two-second credit clearance decisions synthesized on Cloudflare Workers AI using quantized Meta Llama 3.2 models, keeping all sensitive portfolio data on-premise with zero external data leakage.
Connection Pooling: Supabase PostgreSQL accessed in transaction mode to sustain concurrent underwriting workloads without exhausting the connection pool.
Runtime & Framework: Next.js application shell served on the Bun runtime for low-latency request handling.
Risk Visualization & Audit: Real-time risk trajectory charts paired with immutable ledger audits for full decision traceability.
Next.jsBunSupabasePostgreSQLCloudflare Workers AILlama 3.2Basel III
Respective Repositories:
Digital-Wallet-Ecosystem
Repository
Live Demo
Specialized Applications

Domain-Specific Software Suite

Management & Logic Systems

Targeted software for library management, real-time sports scoreboards, and secure voting systems.

Key Learning Points:
Library Management: Desktop UI/UX & CRUD implementation using Java Swing and MySQL.
Sports Scoreboards: Real-time data tracking and event-driven logic.
Secure Voting: Backend logic for data integrity, tallying, and reporting.
Organizational workflow automation: Streamlining administrative tasks through automated scripts.
Java SwingC#.NETSQLUI/UX Design
Respective Repositories:
Library-Management-System-JavaScoreBoard-ProjectVoting-System-Logic
Repository
Full-Stack Development

Full-Stack Development Ecosystems

Scalable Health-Tech & CMS

Scalable web architectures focusing on health-tech and content management using the MERN stack.

Key Learning Points:
MERN Architecture: Building end-to-end JavaScript environments.
State Management: Handling complex user data across React components.
RESTful API Design: Creating seamless communication between Node.js backends and NoSQL databases.
MongoDBExpress.jsReact.jsNode.jsJWT
Respective Repositories:
MERN-Workout-TrackerReact-Blog-App
Repository
System & Mobile

Mobile & System Utility Tools

Native Apps & Performance Logic

Native Android development and performance-oriented system programming using C++ and Java.

Key Learning Points:
Mobile Lifecycle: Managing Activity states and mobile-specific resource constraints.
OOP Optimization: Utilizing C++ and Java for memory-efficient utility tools.
Open Source Standards: Maintaining code quality for global collaboration.
Android SDKJavaC++FirebaseOOP
Respective Repositories:
Android-App-CollectionHacktoberfest-ContributionsCPP-Utility-Library
Repository
Simulations & Advanced Web Development

Camera Simulation Education Tools

React & Three.js Architecture

Educational simulation to study camera anatomy and real-time rendering logic.

Key Learning Points:
Advanced Web Apps: Implementing Three.js for 3D educational tools.
Dynamic Building: Learning dynamic website architecture and browser-based simulations.
Browser-based Game Logic: Applying game development concepts to educational software.
ReactThree.jsSimulationJavaScriptOOP
Respective Repositories:
camera-simulation-for-education-Tools
Repository
Full-Stack Development

Spring Boot & Next.js Full-Stack CRUD App

Enterprise Full-Stack Architecture

Industrial-standard full-stack CRUD application featuring a Spring Boot backend on Render, PostgreSQL database, and Next.js frontend deployed on Netlify.

Key Learning Points:
RESTful API Design: Connecting Spring Boot controllers with Next.js frontend.
Database Management: Utilizing PostgreSQL with Hibernate and JPA entities.
CORS and Cloud Security: Handling secure cross-origin requests between Render and Netlify.
Responsive UI Design: Modern table management with interactive actions.
Spring BootNext.jsPostgreSQLRenderNetlifyJava
Respective Repositories:
springboot-HelloAppfrontend-springboot-crud-app
Repository
Live Demo
Full-Stack Development

Python & Next.js CRUD Project

Dynamic Web Ecosystem

Dynamic full-stack application built with a robust Python backend and a responsive Next.js frontend deployed seamlessly via Vercel.

Key Learning Points:
Python Backend Integration: Building clean endpoints and processing data.
Vercel Deployment: Hosting and scaling full-stack applications efficiently.
Database Connectivity: Secure CRUD operations with relational databases.
PythonNext.jsPostgreSQLVercel
Respective Repositories:
python-nextjs-crud-app
Repository
Cloud Infrastructure & IaC

OpenStack 3-Tier ERP on MicroStack

Web · App · DB with SG-chain isolation

A 3-tier ERP deployed on a single-node MicroStack private cloud (Neutron-OVN). Three isolated provider networks, three chained security groups, a full-featured CRUD ERP web app, provisioned end-to-end with Terraform and verified hop-by-hop with Ansible.

Key Learning Points:
3-tier architecture: isolated web, app and DB networks on one OpenStack host.
Security-group chaining: each tier only allows the tier before it (8000 from web SG, 3306 from app SG) - "buns never meet".
Terraform IaC: keypairs, instances, floating IPs and associations in a single declarative stack.
Ansible handoff: zero-MB playbook proving reachability over the SG chain.
HA & FT: router failover, FIP-following reboots, resize probes and fault injection.
OpenStackMicroStackNeutron-OVNTerraformAnsibleCRUDLinux
Respective Repositories:
Repository
Runbook 
Cloud Architecture & Microservices

Polyglot 3-Tier Enterprise ERP Architecture

Next.js · Spring Boot · PostgreSQL · LocalStack

An enterprise-grade 3-tier ERP architecture designed for isolated multi-AZ deployment. Features end-to-end BCrypt authentication, Spring Data JPA connection pooling, Next.js dynamic user dash, and stress-tested throughput reaching ~500 TPS under concurrent load.

Key Learning Points:
3-Tier Perimeter Isolation: Segregated Public, App, and isolated DB subnets across 2 AZs.
High-Concurrency Benchmarking: Profiled HikariCP connection pools and Tomcat threads with wrk at ~500 TPS.
Cryptographic Auth Pipeline: BCrypt password hashing with CORS-hardened Spring Security filters.
LocalStack Cloud Verification: Simulated dual ALBs, VPC routing, and Secrets Manager integration locally.
Spring BootNext.jsPostgreSQLDockerLocalStackwrkJava 17
Respective Repositories:
erp-demo-backenderp-demo-frontend
Repository
Codespace Live Demo
Developer Identity

Hi, I'm Ashan Dhanushka! 👋

Ashan Dhanushka
University Student
Based in Sri Lanka 🇱🇰

📈 Global Impact

GitHub stats for ashandhanushka

🚀 About Me

I'm a dedicated University Student exploring the intersections of finance and technology. My journey is fueled by a passion for backend logic, distributed systems, and modern software architecture.

Focus Areas
Cloud, Full-Stack, AI/ML and System Administration
Backend Core
Java, Python, Rust, TypeScript, PHP and C#
2026 Milestone
Full-scale Open Source Apps
Workflow
Mastering Clean Code & Scalability
"I speak fluent Python, but my Java is still learning to brew. I believe code is the ultimate form of documentation, though I’m getting much better at commenting!"

🛠 Tech Stack Matrix

PythonJavaSpring BootC#PHPLaravelReactNext.jsMongoDBMySQLAWSExpoQuasarVue.jsGit
My Niche

Four Core Domains

My work sits where these four domains overlap — cloud infrastructure, full-stack product engineering, applied AI, and the Linux operations that keep it all running.

cloud

Cloud & Infrastructure

Cloud-native architecture, infrastructure as code, and containerized deployments.

  • AWS and OpenStack / MicroStack private clouds
  • 3-tier and multi-AZ network topologies
  • Docker containerization and Kubernetes workloads
  • Terraform provisioning with Ansible automation
  • Load balancers, security groups and VPC routing
  • Event-driven pipelines on S3, SQS and LocalStack
AWSTerraformAnsibleDockerKubernetesOpenStack
fullstack

Full-Stack Engineering

End-to-end product delivery across polyglot backends and modern React frontends.

  • Java, Python, PHP, C# and Rust backend services
  • Spring Boot, Laravel, .NET and Node.js APIs
  • Next.js, React and Vue.js frontends
  • PostgreSQL, MongoDB, SQL and Redis data layers
  • Authentication, authorization and CORS hardening
  • REST, SOAP and WebSocket service contracts
TypeScriptJavaPythonReactNext.jsPostgreSQL
ai-ml

AI & Machine Learning

Applied AI systems — telemetry pipelines, edge inference and model-backed decisions.

  • Real-time AI telemetry over binary WebSocket streams
  • Protobuf schemas for machine-vision payloads
  • Detection telemetry: labels, confidence and bounding boxes
  • Edge inference with Llama 3.2 on Cloudflare Workers AI
  • JSONL logging for traceability and analysis
  • Foundations extensible to real image recognition models
LLMsEdge AIProtobufWebSocketsLlama 3.2Python
sysadmin

System Administration

Production Linux operations, observability and high-concurrency reliability work.

  • Ubuntu and Linux server administration and hardening
  • Nginx, systemd, cron and service supervision
  • Performance benchmarking and load testing with wrk
  • High-concurrency tuning of pools and thread models
  • Logging, monitoring dashboards and alerting
  • Backup, recovery and deployment pipelines
LinuxBashNginxsystemdwrkDocker
Communication Terminal

GET IN TOUCH

Polyglot Cloud Engineer & Creative Developer. I build polyglot backend systems across Python, Java and Go, and design cloud-native architectures on AWS and OpenStack — from microservices, containerized deployments and Kubernetes to Terraform/Ansible infrastructure as code and distributed data layers.

Currently interested in projects involving polyglot Python, Java and Go backend development, cloud solutions, fintech platforms, high-concurrency distributed systems and enterprise 3-tier applications. Available for collaborations, academic inquiries, freelance work and professional networking.

Personal Email
ashandhanushka660@gmail.com
Open Mail Client 
Academic ID
wcm24b126@uovt
University of Vocational Technology
Phone Number
0710118916
Voice & SMS Availability
LinkedIn Profile
in/ashan-dhanushka-0b58a52a6
View Profile 

Let's build something extraordinary.

OPEN FOR NEW OPPORTUNITIES AND OPEN SOURCE CONTRIBUTIONS.

GitHub LinkedIn Social