Adam Tang — I turn complex ideas into working products.

Problem to solve

PSA API quotas and browser security checks make certificate lookup unreliable, while code-only marketplace search can produce ambiguous card matches. The workflow needed safer identification routes without pretending blocked data sources were dependable.

What I built

• Designed a route hierarchy that prioritizes direct SNKRDUNK IDs, verified mappings, and exact series/card-code matches before falling back to PSA metadata or browser-assisted lookup.
• Built a Telegram-first workflow that returns card identity, images, grading-condition prices, market context, and multilingual responses for daily collection use.
• Added mapping and history caches, batch summaries, CSV/JSON outputs, diagnostics, and explicit low-confidence or security-check states instead of silently accepting weak matches.

Technical implementation

• Python services use httpx/requests, BeautifulSoup, RapidFuzz, structured mappings, and SNKRDUNK product/condition endpoints for matching and live pricing.
• Playwright is retained as a user-controlled browser fallback for public PSA certificate pages; the workflow detects Cloudflare/security pages and does not treat them as certificate data.
• Telegram commands, route caches, batch processing, environment-based configuration, and deployment profiles turn the research script into a reusable operational tool.

Problem to solve

Personal investment data was fragmented across devices, spreadsheets, market-data sources, and separate Taiwan/US workflows. The product needed a single private workspace without exposing credentials or portfolio data in the browser.

What I built

• Designed the product model for net worth, positions, lots, DCA, realized and unrealized P&L, transfers, and trading journals.
• Built Google OAuth access control, cross-device cloud synchronization, admin approval, and local-to-cloud migration.
• Implemented edge APIs for quotes, symbol search, position selling, and incrementally cached portfolio history.

Technical implementation

• Native HTML/CSS/JavaScript frontend deployed on Cloudflare Pages with Pages Functions as the backend-for-frontend.
• Supabase Auth, Postgres, PostgREST, row-level access patterns, and transactional RPC for position sales.
• Market-data adapters for Nasdaq, Alpha Vantage, Finnhub, TWSE, TPEx, and USD/TWD exchange rates, with fallback logic and route tests.

Problem to solve

A private trading-card collection needed to work as a searchable collection, valuation dashboard, wishlist, and member-only market experience while keeping editorial data easy to maintain.

What I built

• Built the static-site generation pipeline from Notion data, including cached exchange rates and scheduled publishing.
• Designed collection filters, valuation analytics, wishlists, market lookup, shopping, auction, cart, and grading-service prototypes.
• Added Supabase Google identity, independent authorization, admin review, and protected aggregate market APIs.

Technical implementation

• Python/Jinja2 build process converts Notion content into deployable static pages and reusable partials.
• Cloudflare Pages and Functions protect private routes and expose server-side APIs without leaking service credentials.
• Supabase Auth/Postgres provides identity and access boundaries; GitHub Actions rebuilds hourly and refreshes market data on a schedule.

Problem to solve

Taiwan-market research needs consistent data, realistic costs, repeatable backtests, strong validation, and a safe path from strategy output to paper execution before any live deployment.

What I built

• Designed a layered Python package and CLI for data preparation, strategy research, reporting, and broker-neutral execution.
• Implemented Taiwan futures cost models, continuous-contract helpers, strategy comparison, parameter sweeps, and walk-forward validation.
• Integrated paper execution and Shioaji adapters with market-hours, expiry, order-size, kill-switch, rate-limit, and reconciliation guards.

Technical implementation

• Canonical OHLCV pipeline with Yahoo Finance, FinMind, TAIFEX, local CSV, and Shioaji real-time adapters.
• Backtrader event-driven research with eleven strategy templates, external strategy loading, metrics, CSV/JSON reports, and SVG charts.
• Target-position runtime separates strategy decisions from broker orders so the same logic can move from dry-run to simulation safely.

Problem to solve

Daily shipping teams needed a safer way to import shipment plans, scan medical-product UDI codes, catch over-scans or mismatches, and produce an auditable end-of-day result.

What I built

• Modeled the shipment workflow from plan import through order selection, scan validation, review, submission, and final export.
• Built GS1 Element String, HRI, and Digital Link parsing with internal-product mapping and explicit exception states.
• Added SQLite persistence, Excel export, database backup, runtime configuration, feature tiers, license handling, Docker packaging, and integration tests.

Technical implementation

• FastAPI exposes a versioned operational API and serves a focused single-page scanning interface.
• Browser session state keeps in-progress scans temporary; only confirmed orders are committed to SQLite.
• Service modules separate plan import, UDI mapping, validation, submission, reporting, and launcher behavior.

Problem to solve

Dense shipping photos can contain many small Data Matrix codes with perspective, occlusion, and repeated cartons. Missing a code must lead to review rather than an unsafe automatic pass.

What I built

• Developed a multi-box detection and local-ROI search pipeline tuned for lower-band Data Matrix placement on cartons.
• Combined multiple decoder engines, GS1 parsing, product mapping, density-aware rescue budgets, and annotated artifact export.
• Created benchmark histories and PASS/REVIEW gates based on expected counts and decoded completeness.

Technical implementation

• Candidate boxes are ranked toward complete carton hypotheses, then local regions are searched with scale and scene-density aware budgets.
• Decoded content is normalized from GS1 element strings or Digital Links into business fields and mapped to internal products.
• Every run can emit JSON, CSV, candidate data, attempt summaries, benchmark snapshots, and annotated review images.

Problem to solve

A physical card market needed one system for brand presentation, vendor onboarding, booth availability, reservations, rental extras, contract generation, and staff administration.

What I built

• Designed the vendor journey from registration and login through date/booth selection, equipment rental, reservation, and contract creation.
• Built role-protected admin operations for users, bookings, contracts, open dates, rental inventory, and CSV exchange.
• Containerized the Vue client, Node API, and MySQL database with an optional Cloudflare tunnel for demonstrations.

Technical implementation

• Vue 3/Vite single-page frontend with Pinia and route-based Home, Reserve, and Admin experiences.
• Express/Sequelize API handles JWT auth, availability, reservations, staff roles, uploads, and management endpoints.
• PDFKit generates Chinese reservation contracts; Docker volumes preserve contracts and MySQL data.

Problem to solve

Production planners need to query schedules, facts, constraints, and operating knowledge in natural language without letting an LLM invent production data.

What I built

• Designed an agentic orchestration layer that routes questions to relational, graph, or vector tools.
• Built multilingual question/answer pivots, deterministic fallback behavior, seed data, and startup automation.
• Containerized the complete demonstration stack with isolated API and Chainlit dependencies.

Technical implementation

• Postgres stores operational facts and schedules; Neo4j represents semantic metadata and relationships.
• Chroma retrieves planning documents while Ollama provides local embeddings and optional model serving.
• FastAPI orchestrates Graph-to-SQL and Graph-to-Vector tools; Chainlit provides the conversational demo interface.

Problem to solve

Automotive R&D users needed a private assistant that could retrieve engineering evidence, preserve internal knowledge boundaries, and provide useful answers without sending sensitive content to a public model service.

What I built

• Designed local-first RAG and GraphRAG retrieval over domain documents and structured knowledge.
• Built the Chainlit conversational experience, retrieval pipeline, prompt controls, and Docker runtime.
• Connected LLM, graph, vector, and document services behind a modular Python application.

Technical implementation

• Ollama provides local model execution; vector retrieval and graph relationships contribute evidence.
• Python orchestration combines query understanding, retrieval, context assembly, and response generation.
• Chainlit delivers the chat UI while Docker keeps the full environment reproducible on-premises.

Problem to solve

Crisis and resilience stakeholders needed to exchange heterogeneous data with shared meaning, provenance, and reusable analytics across organizational boundaries.

What I built

• Developed Python data-provider and metadata-extraction components for the resilience data space.
• Modeled semantic concepts with ontologies and knowledge graphs, then queried them through SPARQL workflows.
• Contributed requirements, API delivery, CI/CD, documentation, and agile coordination across the project.

Technical implementation

• Python ETL and APIs normalize source data and publish interoperable metadata.
• Ontology and graph layers provide shared semantics and queryable relationships.
• Containerized services and CI/CD support repeatable integration across project partners.

Problem to solve

LLM clients needed a narrow, read-only way to inspect approved knowledge graphs and execute SPARQL without receiving broad database credentials or write access.

What I built

• Implemented an MCP server that exposes GraphDB repository discovery and read-only SPARQL operations as model tools.
• Defined the protocol boundary between conversational clients and the semantic database.
• Published the connector and its usage documentation as an open-source repository.

Technical implementation

• JavaScript MCP server accepts structured tool requests from compatible LLM clients.
• GraphDB HTTP endpoints execute repository discovery and read-only SPARQL queries.
• Responses are normalized for conversational use while the server preserves a constrained access surface.

Problem to solve

Local LLM experimentation becomes difficult to reproduce when model serving, dependencies, persistence, and network settings are installed manually on each machine.

What I built

• Packaged Ollama and its supporting service configuration into a repeatable Docker Compose workflow.
• Documented model startup, persistence, environment settings, and deployment paths.
• Published a public repository and hosted demonstration endpoint for easier evaluation.

Technical implementation

• Docker Compose defines the model runtime, service networking, volumes, and application dependencies.
• Python service code exposes health and model-facing integration points for local or hosted use.
• Environment-based configuration keeps development and cloud deployment paths aligned.

Problem to solve

A new jewelry brand needed a credible online storefront and an operating model that connected discovery, checkout, fulfillment, analytics, and marketing experiments.

What I built

• Owned the product from business model and site structure through launch, payments, content, and fulfillment.
• Implemented analytics and conversion tracking to support marketing decisions.
• Coordinated a lean remote team, vendors, and ongoing product operations.

Technical implementation

• Responsive storefront and structured product content supported search, browsing, and checkout.
• Payment, fulfillment, and analytics services formed the operational commerce stack.
• Campaign and conversion signals fed iterative content and growth decisions.

Problem to solve

A labor union needed an accessible public information hub that members could navigate easily and maintain through a simple deployment workflow.

What I built

• Designed and built the responsive information architecture, content pages, and interaction patterns.
• Connected GitHub source control to AWS Amplify deployment and the production domain.
• Structured member resources so important information could be found without a complex CMS.

Technical implementation

• Static HTML/CSS/JavaScript keeps the public site fast, portable, and inexpensive to operate.
• GitHub provides versioned content and code; AWS Amplify builds and deploys each approved update.
• Domain routing exposes the published site to members and the public.

Problem to solve

XOR is not linearly separable, so it is a compact way to demonstrate why a single perceptron fails and how hidden layers learn nonlinear decision boundaries.

What I built

• Implemented and compared simple neural-network structures for logic prediction.
• Visualized training behavior and predictions in a small reproducible demonstration.
• Documented the experiment as a public learning repository.

Technical implementation

• NumPy represents inputs, weights, activations, loss, and parameter updates.
• A hidden layer introduces nonlinear features required to separate XOR classes.
• Plots and predictions make training behavior inspectable rather than presenting only final accuracy.

Problem to solve

Additive-manufacturing sustainability data spans materials, process steps, energy, and lifecycle impacts, making consistent traceability and comparison difficult.

What I built

• Modeled manufacturing and lifecycle concepts as an ontology and knowledge graph.
• Built Python data-processing steps for lifecycle and sustainability indicators.
• Created a traceable prototype that connects source data, semantic context, and visual analysis.

Technical implementation

• Process and material records are cleaned and aligned to lifecycle-assessment concepts.
• Ontology and graph structures preserve relationships and provenance across manufacturing stages.
• Python analytics derive indicators that can be presented in dashboards or reports.

Problem to solve

Composite helicopter components can sustain internal delamination after impact even when surface damage is limited; simulation needs to reproduce the loading and failure behavior credibly.

What I built

• Prepared composite geometry, mesh, material definitions, contacts, and impact boundary conditions.
• Ran LS-DYNA impact analyses aligned with ASTM D7136 test principles.
• Used Python to post-process force, energy, displacement, and delamination results.

Technical implementation

• HyperMesh builds and checks the layered finite-element model.
• LS-DYNA solves the transient impact response with composite failure and contact behavior.
• Python extracts and compares key histories and spatial damage indicators.

Problem to solve

Single-lap aluminum–CFRP hybrid joints fail through interacting adhesive, interface, and structural mechanisms that are difficult to observe directly in tests.

What I built

• Built and calibrated finite-element models for the hybrid lap-joint specimens.
• Applied cohesive-zone behavior to represent adhesive initiation and progressive failure.
• Automated result extraction and compared simulated force/displacement and failure patterns with experiments.

Technical implementation

• HyperMesh defines joint geometry, mesh, contacts, and material/adhesive regions.
• LS-DYNA solves tensile loading and progressive interface damage.
• Python post-processing aligns simulation outputs with experimental curves and failure observations.

Problem to solve

Sustainability choices combine environmental, economic, and social criteria with different units and stakeholder priorities, so a transparent ranking method was required.

What I built

• Structured the decision hierarchy and pairwise-comparison inputs for Analytic Hierarchy Process weighting.
• Implemented AHP consistency checks and alternative rankings with weighted-sum and TOPSIS methods.
• Built Python/Excel data flows and visualizations to make assumptions and sensitivity visible.

Technical implementation

• Excel inputs capture criteria, alternatives, and stakeholder judgments.
• Python/NumPy calculates normalized matrices, priority vectors, and consistency ratios.
• WSM and TOPSIS compare alternatives and provide cross-method validation.

Problem to solve

Small additively manufactured specimens needed controlled cyclic loading and repeatable data capture to investigate fatigue behavior.

What I built

• Designed the loading concept and integrated motor control, fixtures, sensing, and specimen handling.
• Implemented Python control and data-acquisition logic for repeatable cycles.
• Processed the resulting load/cycle data and documented experimental limitations.

Technical implementation

• Command logic controls the actuator and repeated loading profile.
• Sensors record mechanical response while safety and stop conditions protect the setup.
• Python turns raw samples into fatigue plots and comparison data.

Problem to solve

Wind and solar generation have different market value because production profiles interact with time-varying electricity prices, not just annual energy totals.

What I built

• Prepared generation and electricity-price time series for consistent market-value comparison.
• Implemented capture-price and value-factor calculations for wind and solar scenarios.
• Created plots and documentation that explain the relationship between timing and revenue.

Technical implementation

• Pandas aligns hourly or interval generation with market-price data.
• Python calculates weighted capture prices, value factors, and scenario comparisons.
• Visualizations communicate temporal patterns and differences between technologies.

Problem to solve

Photovoltaic cells and module configurations respond differently to irradiance, mismatch, and bypass behavior, requiring controlled measurement and comparable analysis.

What I built

• Planned and performed photovoltaic I-V measurement comparisons.
• Analyzed cell/module behavior and bypass-diode effects with Python.
• Produced a structured technical report with figures and experimental interpretation.

Technical implementation

• The laboratory setup captures voltage/current pairs under controlled conditions.
• Python calculates key PV indicators and overlays comparable I-V curves.
• LaTeX integrates methods, results, plots, and discussion into a reproducible report.

Problem to solve

Microalbumin spectroscopy signals contained baseline drift and measurement noise that obscured concentration-related patterns.

What I built

• Prepared and inspected spectral datasets from the laboratory measurement workflow.
• Implemented baseline correction and polynomial fitting in MATLAB.
• Supported measurement integration and repeatability with Arduino-connected experimental hardware.

Technical implementation

• Spectrometer and experimental electronics generate raw intensity/wavelength records.
• MATLAB performs preprocessing, baseline estimation, correction, fitting, and visualization.
• Processed spectra are compared across samples to expose usable analytical patterns.

Problem to solve

An injection-molded component required coordinated product geometry, mold design, process simulation, machining, molding, and quality follow-up.

What I built

• Created product and tooling geometry in SolidWorks.
• Used Moldex3D to review fill behavior and process risks before manufacturing.
• Supported CNC/tooling work, molding trials, inspection, and corrective iteration.

Technical implementation

• CAD defines the part, mold, and manufacturing interfaces.
• Moldex3D simulates filling and highlights likely process or design issues.
• CNC tooling, injection trials, and inspection close the loop with physical evidence.

Problem to solve

A quadcopter must estimate attitude and continuously correct four motor outputs fast enough to remain stable despite sensor noise and disturbances.

What I built

• Integrated the frame, motors, ESCs, sensors, power system, and microcontroller.
• Implemented sensor reading, attitude estimation, PID control, and motor mixing in embedded code.
• Tuned and tested the controller iteratively with safety-conscious ground and flight checks.

Technical implementation

• IMU measurements are filtered into roll, pitch, and yaw estimates.
• PID loops compare desired and measured attitude and calculate corrective control signals.
• Motor mixing converts control outputs into four ESC commands for the airframe.