DEV Community: Malawige Inusha Thathsara Gunasekara

Building an Enterprise Climate Intelligence OS

Malawige Inusha Thathsara Gunasekara — Thu, 24 Sep 2026 22:02:15 +0000

How We Won 1st Place at CodeFest Datathon 2026: Building an Enterprise Carbon Intelligence OS

Winning 1st place at the SLIIT CodeFest Datathon 2026 was one of the most intense, rewarding engineering sprints our team has ever experienced.

When most people hear "Datathon," they imagine tuning hyperparameters on an XGBoost model to squeeze out an extra 0.001 on an F₁ score. But this competition was fundamentally different. The challenge tasked us with acting as an elite climate and quantitative consultancy to solve a massive real-world crisis: The multi-billion-dollar financial risk of the global Net-Zero transition.

We were given historical climate, emissions, energy mix, and carbon pricing datasets spanning 2000 to 2026, across 5 international emissions trading systems and 50 countries.

Rather than stopping at exploratory notebooks, we designed, validated, and shipped CarbonPulse OS—an end-to-end Enterprise Carbon Risk & Transition Intelligence Operating System, complete with:

30-Day Allowance Price Forecasting (Classical ARIMA achieving 2.64% average MAPE).
Empirical Event Shock Radar (Scientifically rejecting H₀ by proving climate disasters and policy summits quantitatively move carbon prices).
Stoichiometric Combustion Simulator (R² = 0.945 Random Forest grounded in physical chemistry).
Country Transition Scenario Engine (K-Means archetypes projecting 2026–2030 decarbonization pathways).
A Live, Interactive Web MVP with 1-click automated TCFD & CSRD compliance audit exports.

Figure 1: Full 4-tier system architecture of CarbonPulse OS connecting raw data ingestion to enterprise delivery.

In this deep dive, I'm sharing our complete technical playbook, the counter-intuitive machine learning breakthroughs we discovered, our solution architecture, and the presentation strategy that took us to the top of the podium—without exposing any private competition datasets.

The Macro Problem: Carbon is a Balance Sheet Liability

For decades, corporate carbon footprinting was relegated to glossy Corporate Social Responsibility (CSR) brochures. But today, under statutory Cap-and-Trade compliance systems (EU ETS, UK ETS, California Cap-and-Trade, China ETS), carbon is a statutory, multi-billion-dollar financial liability.

Under the European Union Emissions Trading System (EU ETS):

Emitting 1 metric ton of CO₂ costs upwards of €80 to €100.
A mid-sized industrial emitter producing 1,500,000 tons of CO₂ faces an annual compliance liability exceeding €120 Million.
When unexpected regulatory tightening or extreme weather hits, allowance prices can swing by ±15% in under three weeks—triggering unbudgeted multi-million-dollar cash drains.

Yet, when we investigated legacy enterprise tooling (Bloomberg Terminal, MSCI ESG, S&P Trucost), we noticed a glaring market failure: existing tools only offer static, backward-looking annual survey scores. Energy trading desks and Chief Sustainability Officers (CSOs) had zero daily predictive intelligence linking real-world climate catastrophes and forward policy negotiations to commodity allowance prices.

That became our mission for the Datathon: Bridge physical climate science with quantitative financial econometrics.

Breakthrough 1: Why Classical ARIMA Crushed Machine Learning on Carbon Prices

The first challenge required predicting daily carbon allowance prices for the next 30 trading days across 5 global markets (EU ETS in EUR, California in USD, RGGI in USD, UK ETS in GBP, and China ETS in CNY).

The Battle: ARIMA vs. Gradient Boosted ML

Like many teams, our initial instinct was to throw state-of-the-art Gradient Boosted Trees (LightGBM) at the problem. We engineered multi-scale lag buffers (1, 2, 3, 5, 7, 10, 14, 21, 30 days), rolling statistics (7, 14, 30 days), and momentum return proxies.

Then, we benchmarked this against a classical econometric formulation: ARIMA(1, 1, 1).

Here were our out-of-sample held-out test results:

Carbon Market	Currency	Classical ARIMA (RMSE)	Classical ARIMA (MAPE)	LightGBM ML (MAPE)	Outperformance
California CAT	USD	1.144	2.92%	3.82%	ARIMA (+23.6%)
China ETS	CNY	3.008	2.19%	3.28%	ARIMA (+33.2%)
EU ETS	EUR	2.278	2.22%	2.55%	ARIMA (+12.9%)
RGGI (US)	USD	0.523	2.17%	3.17%	ARIMA (+31.5%)
UK ETS	GBP	2.148	3.69%	6.01%	ARIMA (+38.6%)
OVERALL AVG	—	—	2.64%	3.77%	ARIMA (+30.0% Lead)

Figure 2: 30-Day out-of-sample price forecast comparison across all 5 international allowance markets. Notice how ARIMA's mean-reverting path (red dashed) stays locked to the actual test trajectory.

Why Did Classical Econometrics Win?

This was one of our biggest presentation hooks for the judging panel.

When performing multi-step recursive forecasting (30 trading days out), any single-step machine learning model must feed its own predicted values back into its lag feature buffer for step t+2, t+3, ..., t+30. This causes compounding error drift—small estimation errors snowball exponentially.

In contrast, ARIMA(1, 1, 1) utilizes:

First-order Differencing (d = 1): Stabilizes the stochastic drift and enforces financial stationarity.
Moving Average (q = 1) Shock Absorption: Quickly absorbs idiosyncratic price shocks back toward the structural mean.

# The Winning Econometric Baseline
from statsmodels.tsa.arima.model import ARIMA

def train_arima_baseline(train_series, steps=30):
    model = ARIMA(train_series, order=(1, 1, 1))
    fitted_model = model.fit()
    forecast = fitted_model.forecast(steps=steps)
    return forecast

Lesson: Never assume deep learning or gradient boosting is universally superior. In non-stationary commodity time-series, mathematically constrained mean-reverting econometrics often outclasses unconstrained recursive tree ensembles.

Breakthrough 2: Teaching Machine Learning the Laws of Chemistry

The next objective was to predict sovereign emissions per capita (co2_per_capita_t) using country power generation mixes (Coal, Oil, Gas, Nuclear, Hydro, Solar, Wind, and Other Renewables).

A naive regression model using raw percentages failed because raw percentages ignore economic reality. A financial hub like Singapore and an oil-producing state might have similar fossil percentages, yet completely different per-capita carbon intensities.

Domain-Driven Feature Engineering

We engineered four domain-specific features grounded in IPCC stoichiometric combustion chemistry:

Carbon-Weighted Combustion Intensity Index:

   Index = (Coal% × 1.0) + (Oil% × 0.8) + (Gas% × 0.5)

Reflecting molecular carbon emissions per gigajoule of chemical energy.

Clean-to-Fossil Generation Ratio:

   Ratio = (Renewables% + Nuclear%) / (Fossil Total% + 0.0001)

Coal-to-Gas Switching Efficiency: Measures whether fossil generation is transitioning from high-carbon coal to lower-carbon natural gas bridge fuels.
Fossil-GDP Interaction Metric:

   Interaction = Fossil Total% × Carbon Intensity of GDP

Benchmark Results (5-Fold Cross-Validation, 80/20 Test Split)

Model Architecture	5-Fold CV R²	Test Set R²	Test RMSE (t/person)	Test MAE (t/person)
Linear Regression (OLS)	0.810 ± 0.038	0.798	3.272	2.146
Ridge Regression (L₂)	0.804 ± 0.041	0.784	3.382	2.216
LightGBM Regressor	0.933 ± 0.025	0.926	1.975	0.978
Random Forest Regressor	0.922 ± 0.028	0.9449	1.709	0.901

Figure 3: Out-of-sample actual vs. predicted emissions per capita for Random Forest (R² = 0.9449, RMSE = 1.71 t/person).

Figure 4: Feature importance ranking. Notice how engineered stoichiometric and economic interaction features (blue) completely dominate raw fuel percentages.

Our non-linear Random Forest achieved a Test R² of 0.9449, slashing linear error by 58% down to less than 0.90 tons of CO₂ per person.

Our feature importance analysis confirmed that fossil_gdp_interaction (48.2%) and fuel_carbon_intensity_idx (21.4%) accounted for over 69% of the model's total predictive power.

Breakthrough 3: Rejecting the Null Hypothesis (H₀)

The central research hypothesis of Question 2 was:

"Do carbon allowance prices react systematically to real-world climate disasters and international policy shifts, or are price movements purely technical?"

The Weekend Data Trap Most People Miss

When joining daily trading records with climate event logs, approximately 30% of major international events (including the historic Paris Agreement) occur on weekends or holidays when financial exchanges are closed!

If you perform a naive relational join on date == event_date, you drop these events entirely. Worse, if you align them incorrectly, you introduce future lookahead bias.

We engineered an Effective Market Trading Date algorithm that dynamically maps weekend events to the exact opening minute of the following trading session:

# Calendar Synchronization Without Lookahead Leakage
all_trading_dates = np.sort(df_carbon['date'].unique())

def map_to_next_trading_day(event_date):
    idx = np.searchsorted(all_trading_dates, np.datetime64(event_date))
    if idx < len(all_trading_dates):
        return pd.to_datetime(all_trading_dates[idx])
    return event_date

Cumulative Abnormal Returns (CAR) Event Study

Using financial event study methodology on the EU ETS, we analyzed price action across [-10, +15] trading-day event windows:

Fukushima Nuclear Disaster (2011): Triggered an immediate +11.4% Cumulative Abnormal Return (CAR) as European utilities scrambled to secure coal and gas allowances to offset nuclear baseload shutdowns.
EU Fit-for-55 Policy Announcement (2021): Catalyzed a massive +15.2% CAR surge within 15 trading days.

Figure 5: Cumulative Abnormal Returns (CAR %) around historical climate disasters and policy treaties (t = 0 denotes announcement date).

The Verdict: Directional Movement Lift Across ALL 5 Markets

We trained identical LightGBM classifiers to predict next-day directional movement (UP vs. DOWN/FLAT) on an 80/20 chronological test split:

Baseline Model: Technical price lags and rolling return indicators only.
Event-Augmented Model: Technical lags + Event proximity features (days_since_last_event, days_until_next_policy, exponential decay τ = 30d, and regional jurisdiction matching).

Carbon Market	Test Samples	Baseline Directional Acc.	Event-Augmented Acc.	Accuracy Lift	Event-Augmented AUC	Hypothesis Verdict
UK ETS	253	51.78%	52.96%	+1.19%	0.518	REJECT H₀
RGGI (US)	913	49.18%	50.16%	+0.99%	0.532	REJECT H₀
EU ETS	1,091	48.49%	49.40%	+0.92%	0.507	REJECT H₀
China ETS	244	53.28%	54.10%	+0.82%	0.588 (+0.051)	REJECT H₀
California	644	49.53%	50.31%	+0.78%	0.512	REJECT H₀

Figure 6: ROC curve comparison on the EU ETS. Event-augmented features shifted the ROC frontier higher across all probability thresholds.

Figure 7: Top event features. The forward-looking countdown feature (event_days_until_policy) emerged as the strongest shock predictor.

Across every single carbon market on Earth, event-augmented features generated a verified positive accuracy lift.

The single most influential feature was event_days_until_policy. Markets don't just react after a treaty is signed—traders speculatively accumulate allowances weeks ahead of scheduled UN COP summits.

Breakthrough 4: Uncovering 2030 Sovereign Transition Archetypes

Using unsupervised K-Means Clustering (k = 3) on 26 years of annualized renewable adoption rates across 50 countries, the world grouped cleanly into three distinct decarbonization archetypes:

Figure 8: Spatial separation of sovereign decarbonization archetypes across 50 countries.

Figure 9: 26-year historical trajectory of renewable energy penetration for representative countries in each archetype.

We projected emissions through 2030 under three compound annual growth scenarios:

Business-as-Usual (BAU): Continuing the recent 5-year trend.
Moderate Transition: -2.0% annual CAGR reduction modifier.
Accelerated Transition: -5.0% annual CAGR reduction modifier (Net-Zero trajectory).

Figure 10: Multi-pathway forecast curves (2026–2030) for top sovereign emitters.

Macro Insight: Under an Accelerated Transition, top global emitters reach Peak Emissions before 2029, reversing decades of upward momentum.

The Interactive Web MVP: Live Demonstration

Judges love working software. Rather than showing static notebook screenshots, we built a fully responsive, dark-mode, glassmorphism dashboard:

Figure 11: The live CarbonPulse OS interface displaying real-time price monitoring, shock injection, and stoichiometric fuel sliders.

Core MVP Capabilities:

Multi-Market Allowance Monitor: Live currency tickers across EU ETS (€), California ($), UK ETS (£), RGGI ($), and China ETS (¥) with toggleable 30-day forecast curves and 95% confidence bounds.
Event Shock Injector: Interactive buttons allowing traders to inject simulated historical or forward shocks (e.g., Nuclear Baseload Trip +11.4% CAR, Statutory Cap Cut +15.2% CAR) and observe the projected volatility cone in real time.
Stoichiometric Fuel Sliders: Interactive sliders for Coal, Oil, Gas, Nuclear, and Renewables that dynamically recompute corporate Scope 1 emissions and 2030 financial liabilities using our trained Random Forest model.
1-Click TCFD Audit Export: Generates a certified executive compliance report ready for board auditing under EU CSRD (ESRS E1) guidelines.

The Commercial Strategy: Pitching for the Win

The final 10-minute presentation required translating technical modeling into an investment-ready business pitch:

Target Market:
- TAM: $12.4 Billion by 2030 (Global climate risk analytics and ESG carbon accounting).
- SAM: $2.8 Billion (~15,000 compliance industrial facilities under mandatory ETS + top 400 energy hedge funds).
- SOM: $85 Million (Capturing 3% of European and North American industrial emitters in 36 months).
Enterprise SaaS Monetization:
- Analyst Tier: $1,500/month (projections, monthly PDF reports).
- Trading Desk Tier: $5,000/month (sub-second API, shock radar alerts).
- Enterprise Industrial Suite: $75,000 – $150,000/year (custom plant transition simulator, dedicated quant support).
Unit Economics:
- Customer Acquisition Cost (CAC): $12,000
- Annual Contract Value (ACV): $48,000
- Lifetime Value (LTV): $144,000
- LTV / CAC Ratio: 12.0x (Payback period: 3.5 months)
- Projected Year 3 ARR: $18.24 Million (EBITDA positive at Month 22).

Figure 12: 3-Year Annual Recurring Revenue (ARR) growth trajectory reaching $18.2M by Year 3.

5 Lessons for Winning Datathons and Hackathons

Question Deep Learning Defaults: In non-stationary time-series data, classical statistical models (like ARIMA with differencing) frequently outperform deep learning and recursive tree ensembles. Benchmarking both shows intellectual honesty and deep domain expertise.
Feature Engineering Trumps Model Tuning: Encoding the physical laws of chemistry into our features increased R² from 0.79 (OLS) to 0.945 (Random Forest). Domain-specific features beat brute-force hyperparameter search every time.
Handle Edge Cases at the Ingestion Boundary: The weekend trading calendar problem in Question 2 could have wrecked our hypothesis test. Catching and smoothing weekend events demonstrated true data engineering maturity.
Don't Stop at the Notebook: Turning code into an interactive web interface transformed our project from a collection of CSVs into a viable commercial product.
Tell a Financial Story: Judges care about impact. Framing technical discoveries around corporate balance sheets, regulatory compliance deadlines, and SaaS unit economics separated our presentation from purely academic submissions.

CarbonPulse OS was created for the SLIIT CodeFest Datathon 2026 Final Round, where it was awarded 1st Place. All models were developed in Python using Statsmodels, Scikit-Learn, LightGBM, and deployed with Vanilla ES6 & CSS3.

💬 Have you seen classical statistical models beat modern ML in your own projects? How are you approaching climate risk in your data pipelines? Let's discuss in the comments below!

From 48M Records to Top 8 Finalists: How We Built an End-to-End Urban Flow AI

Malawige Inusha Thathsara Gunasekara — Thu, 24 Sep 2026 20:50:13 +0000

We have some exciting news to share! 🎉

Our team, DataMinds, competed in the prestigious SLIIT CodeFest Datathon 2026 and proudly secured a spot as Finalists (Top 8 teams) in the Urban Flow Analytics Data Challenge!

In this competition, we tackled a massive, real-world urban transit dataset containing 48.6 million trip records across 260+ urban zones. The challenge demanded much more than just training a model in a Jupyter Notebook: it required building a production-ready, mathematically sound, and business-viable end-to-end data platform covering everything from chunked streaming data pipelines and spatio-temporal forecasting to an AI-powered executive platform.

Here is the complete behind-the-scenes breakdown of our architectural strategy, the data engineering traps we avoided, our modeling breakthroughs, and the engineering principles that helped us reach the Top 8.

🎥 The 4-Minute Walkthrough

If you prefer a visual walkthrough, check out our official demo video demonstrating the full pipeline, interactive dashboard, and conversational AI mobility assistant:

(Link: https://youtu.be/rUpk545ku88)

🏗️ High-Level System Architecture

Rather than treating the challenge as isolated competition tasks, we engineered a cohesive 4-Tier Architecture that bridges raw streaming telemetry to executive decision-making:

1. Taming 48.6 Million Records Without Running Out of Memory

Working with tens of millions of raw geospatial records presents two massive hurdles:

Memory limits: A naive pd.read_csv() on 48.6 million rows with 20+ columns will immediately crash standard workstations or cloud instances with Out-Of-Memory (OOM) errors.
Real-world data anomalies: Real mobility data is filled with sensor noise, GPS dropouts, fare metering glitches, and data logging bugs.

Chunked Streaming Ingestion

To maintain sub-gigabyte RAM footprints during data auditing, we used Python generators with chunked processing (chunksize=100_000):

def stream_audit(csv_path, chunk_size=100_000):
    total_records = 0
    anomalies = {"negative_fare": 0, "excessive_speed": 0, "zero_duration": 0}

    for chunk in pd.read_csv(csv_path, chunksize=chunk_size):
        # Calculate trip duration and implied speed
        duration_hours = (chunk['dropoff_datetime'] - chunk['pickup_datetime']).dt.total_seconds() / 3600.0
        implied_mph = chunk['trip_distance'] / duration_hours.replace(0, np.nan)

        # Track edge cases
        anomalies["negative_fare"] += (chunk['fare_amount'] <= 0).sum()
        anomalies["excessive_speed"] += (implied_mph > 100).sum()
        anomalies["zero_duration"] += (duration_hours <= 0).sum()
        total_records += len(chunk)

    return total_records, anomalies

The "Speed Trap" and Temporal Anomaly Cleaning

Through our systematic audit across all 48.6M rows, we discovered and programmatically filtered out critical real-world edge cases:

Teleportation glitches: Trips logging positive distance but zero duration.
Physical speed violations: Urban taxi trips logging implied velocities exceeding 100 mph (often GPS drift or corrupt timestamps).
Billing corrections & disputes: Trips with negative fares or negative tip amounts.
Zone boundary mismatches: Trips with missing or non-existent zone IDs.

2. Preventing Data Leakage (The Competition Trap)

A common mistake in ML hackathons is data leakage. If you leak post-trip information into an upfront prediction model, your leaderboard score looks amazing, but your model is completely useless in production.

Chronological Holdouts vs. Random Splits

Random train_test_split on time-series mobility data is fatal—it allows models to learn from the future to predict the past. We enforced strict chronological partitioning:

Training Period: 9 months of historical data
Validation Period: 2 months of subsequent data
Testing Holdout: Final future month (never seen during feature extraction or tuning)

Pre-Trip Only Features

For our Upfront Fare and Duration models, we restricted feature engineering strictly to information available before the passenger steps into the vehicle:

Cyclical Temporal Encodings: sin(2π * hour / 24) and cos(2π * hour / 24) to preserve diurnal continuity (midnight connects smoothly to 1 AM).
Historical Zone Congestion: Rolling 4-week historical pickup velocity per zone pair.
Surge Multipliers: Real-time demand-to-supply ratio proxy computed dynamically.

3. The Supervised Modeling Tournament

We benchmarked multiple architectures across our holdout test set to select the optimal production model:

Model Architecture	Fare R²	Fare RMSE ($)	Duration R²	Duration RMSE (min)	Inference Latency
Ordinary Least Squares (OLS)	0.812	$7.14	0.621	9.85 min	0.8 ms
Random Forest Regressor	0.941	$4.12	0.789	6.94 min	45.2 ms
LightGBM Regressor (Winner - Fare)	0.9657	$3.25	0.8142	6.55 min	2.1 ms
XGBoost Regressor (Winner - Duration)	0.9612	$3.41	0.8268	6.39 min	3.4 ms

Why Gradient Boosting Triumphed

Gradient boosting trees handled the non-linear relationship between Manhattan distance, toll zones, and peak-hour traffic multipliers effortlessly. LightGBM provided lightning-fast inference with sub-cent precision, while XGBoost effectively captured the heavy-tailed variance in urban traffic delays.

4. Spatio-Temporal Forecasting & Origin-Destination Corridors

Urban mobility is heavily spatial. Having accurate pricing is only half the battle; fleet operators must know where demand will surge 24, 48, and 72 hours in advance.

Autoregressive Lag-Based Forecasting

We aggregated zone-level trip demand into hourly buckets and engineered multi-scale temporal lag features:

Immediate Autoregressive Lags: t-1, t-2, t-3 hours.
Diurnal Seasonality Lags: t-24, t-48, t-72 hours (same hour over preceding days).
Weekly Seasonality Lags: t-168 hours (same day and hour of the previous week).

Our forecaster achieved a test RMSE of ~1.00 to 1.22 trips/hour across all major urban zones, allowing dispatchers to pre-position fleet vehicles before surges materialized.

4 Time-Slice OD Flow Clustering

By clustering pickup-to-dropoff vectors across Morning Rush (07:00–10:00), Midday (11:00–14:00), Evening Rush (16:00–19:00), and Late Night (22:00–02:00), we revealed major commercial arterial corridors and airport shuttle dynamics, illuminating severe deadheading (empty return) imbalances.

5. From Raw Code to Executive Decision-Making

Judges at modern hackathons don't just want .ipynb files; they want to see how engineering impacts business. We translated our models into an Executive Command Center built with Streamlit:

1. The Conversational AI Mobility Assistant

We integrated a natural language interface that allows city planners and dispatch managers to ask plain-English questions:

"What are the top 5 revenue-generating pickup zones during the Friday evening rush?"

The Innovation — Ambiguity Guardrails:
Real users often ask vague questions like "Show me the best zones". Rather than letting the AI hallucinate or make unsafe assumptions, our engine implements strict guardrails that detect ambiguity and clarify whether the user intends "highest volume", "highest fare margin", or "fastest turnaround time".

2. The $51.8M ROI Financial Model

We mapped model improvements directly to bottom-line business metrics:

Deadhead Reduction: Pre-dispatching idle vehicles based on our 24h forecaster reduces empty miles by 14.2%.
Airport Reverse-Trips: Pairing drop-offs at airport terminals with immediate outbound demand captures substantial hidden margins.
Estimated Annual Network Gain: Over $51.8 Million across the city transit ecosystem.

6. Four Lessons That Helped Us Secure the Top 8

If you are competing in data science competitions or datathons, here are four principles that made the difference for Team DataMinds:

Clean Data Beats Fancy Ensembles: Spending 40% of our time auditing anomalies across the 48.6M records yielded vastly higher accuracy gains than endless hyperparameter tuning on noisy data.
Respect the Temporal Dimension: Never use standard K-fold cross-validation or random splits on temporal data. A leak-free validation strategy ensures that your local score matches real-world performance.
Build Modular, Reusable Code: We moved all logic out of messy notebooks into modular Python packages (src/data_cleaner.py, src/supervised_models.py, src/demand_forecaster.py). This allowed our notebook, test scripts, and UI to share the exact same underlying logic.
Tell a Clear Story: A technical report or dashboard should not just be a collection of charts. Frame your findings as a business narrative: Problem → Solution → Measurable Economic Value.

🏁 Looking Forward to the Finals!

Reaching the Top 8 Finalist stage among brilliant teams across the country is an incredible milestone for Team DataMinds.

A huge thank you to the SLIIT CodeFest Datathon 2026 organizers and judges for organizing such an inspiring, high-impact data challenge.

Are you building with large-scale mobility data or competing in data challenges? Drop your thoughts or questions in the comments below!

I Tackled the Planet of Lana Language Challenge by Building an AI Translator & Voice Synthesizer

Malawige Inusha Thathsara Gunasekara — Wed, 09 Sep 2026 14:26:05 +0000

I tackled the challenge in a different way, and created this project as my answer.

When the indie studio Wishfully released the official Language Companion booklet (PoL_LanguageCompanion.pdf) for Planet of Lana II: Children of the Leaf, they ended it on page 13 with an irresistible invitation to the community:

"Congratulations, you’ve reached the end of this intensive crash course in Novo Terali! We hope you’ve enjoyed learning a bit more about Lana’s native tongue, and that your understanding of Novo as a whole has deepened in the process.

Now that you are completely fluent, we would love to hear from you in your best Novo Terali! Share a short (or long!) shoutout in your new favorite language on social media and tag us @planetoflana - we can’t wait to see it!"

Most players reading that would string together three words from the mini-glossary—like "Tiai Lana!" ("Hello Lana!")—tweet it with a screenshot, and call it a day.

I couldn't stop there.

The booklet provided around 80 canonical vocabulary words, basic commands, pronouns, numbers, and a handful of translated game scenes. But how can anyone truly be "fluent" when whole swathes of everyday vocabulary and grammar are still undiscovered?

Instead of just posting a one-line tweet, I asked myself:

What if anyone could translate anything into Novo Terali? What if we could reverse-engineer the linguistic rules from the booklet, marry them with an LLM extrapolation engine, back it with an acoustic voice synthesizer, and build a living, self-healing codex that speaks the language in real time?

That question led to NovoGen — an open-source, full-stack conlang translator, speech synthesizer, and dictionary manager for Planet of Lana.

Here is the story of how it was engineered, the technical hurdles encountered along the way, and what it takes to bring a fictional language to life with modern web and AI technologies.

1. Deconstructing Novo Terali: The Lore & Linguistics

In the Planet of Lana universe, Novo Terali (literally "New Speak") was created on Earth as an accessible auxiliary language designed to unite humanity during the multi-generational Fata te Cora ("Seed and Leaf") space mission. Centuries later, on the planet Novo, survivors preserved and evolved it into the melodic dialect spoken by Lana, her sister Elo, and the villagers of Tailo.

Before writing a single line of backend code, I extracted and analyzed every rule documented in the booklet:

                  ┌──────────────────────────────────────────────┐
                  │          NOVO TERALI PHONOTACTICS            │
                  ├──────────────────────────────────────────────┤
                  │  Vowels:      a [ah], e [eh], i [ee],        │
                  │               o [oh], u [oo] (pure Italian)  │
                  │  Diphthongs:  ai, ia, ea, oa, ui (unclipped) │
                  │  Consonants:  t/d aspirated, rolled 'r',     │
                  │               'h' voiced, no silent letters  │
                  │  Stress:      Light stress on first syllable │
                  │  Rhythm:      Calm, melodic, even pacing     │
                  └──────────────────────────────────────────────┘

Morphological Patterns Discovered:

Subject-Verb-Object (SVO) sentence structure ("Ona fatum tia" = "I believe you").
Negation: Direct marker dieh placed before verbs ("Ona dieh fatum" = "I do not believe").
Agglutinative Suffixes:
- -em: Plural/verbal inflection (olai → olaiem = "go" → "did you go?").
- -ari: Agent/actor noun suffix (djimo "make" → djimari "maker/creator"; capitari "director").
- oti-: Honorific or co-prefix (oti-capitari = "co-director").
Philosophical Roots:
- Fata: Predecessor, seed, origin, parent.
- Cora: Successor, leaf, progeny, child, future.

2. Architecture Overview: Local-First Meets Cloud-Native

One core design philosophy was that NovoGen must never depend exclusively on third-party cloud APIs. If a user runs it offline without an API key, it should function seamlessly using local compute. If deployed to production, it should scale on serverless infrastructure.

                     ┌───────────────────────────────┐
                     │       Next.js App Router      │
                     │    Tailwind / Vanilla CSS     │
                     └───────────────┬───────────────┘
                                     │
                        POST /api/translate
                                     │
                     ┌───────────────▼───────────────┐
                     │   In-Memory Rate Limiter      │
                     │  (Sliding-Window, 30 req/min) │
                     └───────────────┬───────────────┘
                                     │
                     ┌───────────────▼───────────────┐
                     │  Multi-Tier Translation Engine │
                     └───────────────┬───────────────┘
                                     │
         ┌───────────────────────────┼───────────────────────────┐
         │                           │                           │
 1. Exact SQLite Match      2. Rule Agglutination       3. LLM Extrapolation
    (Canonical Lore DB)        (Suffixes & Modifiers)       (Gemini 3.1 / Ollama)
         │                           │                           │
         └───────────────────────────┼───────────────────────────┘
                                     │
                     ┌───────────────▼───────────────┐
                     │  Phonotactic Quarantine Guard │
                     │ (Anti-Gibberish Verification) │
                     └───────────────┬───────────────┘
                                     │
                     ┌───────────────▼───────────────┐
                     │      ElevenLabs Voice API     │
                     │    (Gigi Voice Model Tuning)  │
                     └───────────────────────────────┘

3. Challenge #1: Hallucination Prevention in Conlang Extrapolation

Because the canonical dictionary has only ~80 terms, users translating sentences like "Look at the ancient machine in the forest" require new vocabulary.

If you give an LLM free rein, it will hallucinate English words with random accents or invent sounds that violate the fictional world's phonotactics.

To solve this, I designed a multi-tier fallback system:

Tier 1 (Canonical SQLite Lookup): If an exact phrase or word exists in novo_dictionary.db (seeded directly from the companion booklet), return it immediately with is_canonical = 1.
Tier 2 (Morphological Rules): Check if the word can be constructed via known prefixes and suffixes (e.g., compounding fata or appending -ari).
Tier 3 (Constrained Generative Extrapolation): Prompt Google Gemini 3.1 Flash (or a local Ollama model like llama3.2 or mistral) using an ironclad conlang system prompt:

// System instruction excerpt enforced during translation
const CONLANG_PROMPT = `
You are the official linguistic translator for Novo Terali from Planet of Lana.
Follow these inviolable phonotactic constraints:
1. Every vowel is strictly: a [ah], e [eh], i [ee], o [oh], u [oo].
2. No consonant clusters exceeding 2 consonants; never use 'x', 'q', or 'z'.
3. Extrapolated roots MUST use open syllables (CV or CVC patterns like 'talo', 'suni', 'kora').
4. Compound from known roots where possible (e.g., 'machine' -> 'meka-fata').
5. Canonical vocabulary is SACRED: Never overwrite 'Tiai' (Hello), 'Cora' (Child/Leaf), etc.
Return strictly structured JSON containing translation, IPA phonetics, and grammar breakdown.
`;

When an extrapolated word is generated, it is tagged as extrapolated and cached in SQLite so that subsequent translations remain 100% consistent across sessions.

4. Challenge #2: The Anti-Gibberish Quarantine Guard

Once the app went online, a new vulnerability emerged: cache pollution via keyboard mashing.

If someone types "leftofkfmv" or "asdfghjkl", the LLM would dutifully attempt to coin a poetic Novo Terali term for it, saving garbage into the shared SQLite dictionary.

To combat this without adding perceptible latency, I built a two-stage Linguistic Quarantine Layer (src/lib/validator.ts):

Heuristic Phonotactic Analysis (< 0.1ms):
- Rejects repetitive character streaks (/([a-z])\1{2,}/i).
- Rejects impossible English consonant clusters (/[bcdfghjklmnpqrstvwxz]{4,}/i, exempting valid sequences like spl, str, ngth).
- Rejects vowel-less tokens longer than 2 characters.
- Rejects extreme single-word lengths (> 24 chars).
Offline English Lemma Verification (< 0.2ms):
- Loaded a curated set of 45,000 common English words into a fast Set<string>.
- Words failing both checks are rejected from the translation pipeline and logged to data/quarantine_log.json.

export function validateQuery(query: string): ValidationResult {
  const tokens = query.trim().toLowerCase().split(/\s+/);
  for (const token of tokens) {
    if (isImpossibleCluster(token) || isRepetitiveMash(token)) {
      return { isValid: false, reason: "Phonotactic violation detected" };
    }
  }
  return { isValid: true };
}

To give developers and administrators complete control, I added a dedicated Quarantine Admin Panel directly in the UI. Administrators authenticate using an ADMIN_KEY header, inspect suspicious inputs, approve verified terms into the canonical codex, or flush fraudulent entries with one click.

5. Challenge #3: Giving Lana a Voice with Acoustic Tuning

A conlang only feels alive when you can hear it spoken.

Planet of Lana features evocative, emotional voice acting. The developer notes highlighted that Italian voice actors captured the cadence best because of the open vowels and tapped consonants.

To reproduce this, I integrated the ElevenLabs Text-to-Speech API, selecting the Gigi voice model (a youthful, melodic tone) and meticulously calibrating its acoustic profile:

const voiceSettings = {
  voice_id: "Qd7hDo3tdwmASCs5vLEB", // Gigi
  model_id: "eleven_multilingual_v2",
  voice_settings: {
    stability: 0.82,          // High stability keeps Italianate vowels consistent
    similarity_boost: 0.85,   // Accurately locks to the vocal timbre
    style: 0.0,               // Neutral expressive base prevents over-dramatization
    speed: 0.85               // 15% reduction matches the calm, unhurried Novo pace
  }
};

When users click the speaker button next to any phrase, the server streams high-fidelity 44.1kHz audio in under 400ms. If ElevenLabs is not configured, the app gracefully falls back to the browser's native Web Speech API with an Italian phonetic voice profile.

6. Deployment & Cloud Hardening

To make NovoGen accessible worldwide, I packaged it as a multi-stage Docker container and deployed it to Google Cloud Run:

Container Size: Reduced using Next.js standalone output mode (output: "standalone").
Dynamic Persistence: Cloud Run containers use a stateless root filesystem. I wrote an automated bootstrap script that copies novo_dictionary.db to /tmp upon startup, granting the SQLite engine full read-write capabilities during execution.
Rate Limiting: Implemented an in-memory sliding-window limiter (src/lib/rateLimit.ts) enforcing 30 translations/min and 10 voice syntheses/min per IP to protect downstream APIs from quota abuse.
Custom Domain: Mapped to https://novogen.inusha.me backed by Google-managed SSL certificates.

7. The Result: Taking the Challenge to the Stars

Here is what the translation engine can do.

Example 1: Canonical Dialogue Match

English: "We have to stop them, Lana."
Novo Terali: "Ite o imaiem, Lana."
Breakdown: Canonical sentence from Chapter 3 of the companion guide.

Example 2: Complex Extrapolated Expression

English: "Listen to the music of the stars, little child."
Novo Terali: "Teno lo sonari de eora stel, cora."
Breakdown:
- Teno (listen) — coined root adhering to CV phonology.
- sonari (music) — derived from son (sound) + -ari (nominalizer).
- cora — preserved canonical cultural root for child/leaf.

Try It Out!

🌐 Live Web Application: https://novogen.inusha.me

To the team at Wishfully (@planetoflana): You asked us for a shoutout in Novo Terali.

Instead, I built an entire engine so the whole world can speak it:

"Ite fatum tia, Wishfully. Tiai Novo Terali!"

(We believe in you, Wishfully. Long live Novo Terali!)

Multi-Agent Gift Recommendation Engine Powered by Google ADK & Gemini

Malawige Inusha Thathsara Gunasekara — Fri, 21 Aug 2026 15:27:55 +0000

This post is my submission for DEV Education Track: Build Multi-Agent Systems with ADK.

Finding the perfect, thoughtful gift shouldn't feel like a chore.

Whether it's for a birthday, anniversary, or holiday, we all experience gift-buying paralysis:

Generic suggestions: "Just buy them a mug or a generic gift card."
Budget anxiety: Falling in love with an idea only to find out it costs 3x what you planned to spend.
Missing the subtle nuances: Forgetting that someone dislikes clutter, lives in a tiny apartment, or prefers practical experiences over physical objects.

To solve this, I built GiftAdvisor. It is an intelligent, consumer-friendly gift recommendation system built with Google Agent Development Kit (ADK), Gemini (gemini-3.1-flash-lite), and deployed seamlessly to Google Cloud Run.

Live Demo & Links

Live Cloud Run App: https://gift-advisor-1008832068452.us-central1.run.app
GitHub Repository: https://github.com/inusha-thathsara/Multi-Agent-Gift-Idea-Generator-with-Google-ADK

What I Built

GiftAdvisor transforms unstructured descriptions of a person into tailored, ranked, and strictly budget-compliant gift recommendations.

Instead of dumping everything into a single monolithic prompt, GiftAdvisor splits the cognitive load across three specialized AI agents orchestrated via Google ADK:

Profile Analyzer Agent: Understands the human behind the prompt (lifestyle, hobbies, aesthetic preferences, and explicit anti-preferences).
Idea Finder Agent: Brainstorms creative, thoughtful candidate gifts across multiple categories with estimated market prices.
Budget Filter Agent: Audits estimated prices, filters out anything exceeding the user's hard budget limit, swaps in budget-friendly alternatives, and delivers a ranked curation.

Key Highlights & Features

Pure Multi-Agent Pipeline: Built using Google ADK's LlmAgent, SequentialAgent, and InMemorySessionService.
Zero-Overhead Scale-to-Zero: Deployed to Google Cloud Run with min-instances=0 (scales to zero when idle for $0.00 base cost).
Modern Glassmorphism UI: Intuitive dark-mode consumer interface with 1-click preset profiles, interactive budget slider, and live pipeline stage tracking.
Comprehensive Export System: Export recommendations with 1 click to Markdown (.md), JSON (.json), Clipboard, or Print / Save as PDF.

Cloud Run Embed

1. Profile Analyzer Agent (`ProfileAnalyzerAgent`)

Role: Empathy & Persona Architect.
What it does: Ingests raw user inputs (e.g., "My 29yo sister loves specialty pour-over coffee and houseplants, but lives in a small apartment"). It extracts core interests, lifestyle dimensions, emotional tone, and most importantly, anti-preferences (e.g., no large items, avoid generic mugs).
ADK Output Key: recipient_profile

profile_analyzer_agent = LlmAgent(
    name="ProfileAnalyzerAgent",
    model=model_name,
    instruction="""
    You are an expert gift persona analyzer.
    Analyze the recipient's description, occasion, and relationship.
    Extract key traits, hobbies, lifestyle context, and explicit anti-preferences (what to avoid).
    Save your structured analysis to session state key 'recipient_profile'.
    """,
    output_key="recipient_profile",
)

2. Idea Finder Agent (`IdeaFinderAgent`)

Role: Creative Ideation Specialist.
What it does: Reads {recipient_profile} from the session state and ideates 6–10 candidate ideas across diverse categories (e.g., Experiential, Practical Everyday, Consumable / Artisan, Sentimental). It attaches realistic estimated market prices to every item.
ADK Output Key: candidate_gift_ideas

idea_finder_agent = LlmAgent(
    name="IdeaFinderAgent",
    model=model_name,
    instruction="""
    You are a creative gift brainstormer.
    Given the recipient profile:
    {recipient_profile}

    Brainstorm 6 to 10 distinct, creative gift ideas across multiple categories.
    For each idea, provide a realistic estimated market price.
    Save your candidate ideas to session state key 'candidate_gift_ideas'.
    """,
    output_key="candidate_gift_ideas",
)

3. Budget Filter Agent (`BudgetFilterAgent`)

Role: Financial Auditor & Final Curator.
What it does: Reads {candidate_gift_ideas}, {budget_limit}, and {currency}. It validates each candidate against the budget ceiling. Any item that exceeds the budget is logged in an Elimination Audit and replaced with a budget-friendly alternative. The agent then organizes recommendations into budget tiers (Splurge, Sweet Spot, Budget Friendly) with specific buying advice.
ADK Output Key: final_gift_recommendations

budget_filter_agent = LlmAgent(
    name="BudgetFilterAgent",
    model=model_name,
    instruction="""
    You are a meticulous gift budget auditor and curator.
    Budget Limit: {budget_limit} {currency}
    Candidate Ideas:
    {candidate_gift_ideas}

    1. Audit each idea against the budget ceiling.
    2. Eliminate items that exceed the limit and suggest budget-friendly alternatives.
    3. Present the Top 3-5 Recommended Gifts formatted into budget tiers with rationale.
    Save the final report to session state key 'final_gift_recommendations'.
    """,
    output_key="final_gift_recommendations",
)

4. Orchestration with `SequentialAgent`

Google ADK makes chaining agents intuitive using SequentialAgent. State flows from one agent's output_key directly into the next agent's prompt template variables:

gift_advisor_pipeline = SequentialAgent(
    name="GiftAdvisorPipeline",
    sub_agents=[
        profile_analyzer_agent,
        idea_finder_agent,
        budget_filter_agent,
    ],
)

Implementation & Architecture

Backend Tech Stack

Framework: Python 3.12, FastAPI, Uvicorn
Agent Framework: google-adk (Agent Development Kit v2.7.0)
Model: gemini-3.1-flash-lite (via google-genai)
Deployment: Google Cloud Run (Containerized via Docker)

Cloud Run Production Optimization

To keep running costs near $0.00 while maintaining rapid startup times:

min-instances = 0: Cloud Run spins down to zero instances when no traffic is being served.
memory = 512MiB & cpu = 1 vCPU: Lightweight footprint optimized for async FastAPI and Google ADK orchestration.
gemini-3.1-flash-lite: Ultra-fast latency with minimal token consumption.

Key Learnings

Separation of Concerns Prevents Hallucination:
When asking a single LLM prompt to analyze personality, brainstorm 10 items, and filter by budget simultaneously, it often ignores budget limits or produces bland suggestions. By decoupling Analysis -> Ideation -> Budget Auditing into separate ADK agents, each agent performs its task with significantly higher precision.
Session State is the Superpower of ADK:
Using InMemorySessionService and prompt variable injection ({recipient_profile}, {candidate_gift_ideas}) made passing structured context between agents clean, traceable, and modular.
Cloud Run + Gemini is a Perfect Match:
Deploying containerized Python agent applications to Cloud Run gives you an instant HTTPS public API with scale-to-zero economics. No idle server bills, automatic TLS certificates, and global scaling out of the box.

Conclusion & What's Next

Building GiftAdvisor with Google ADK demonstrated how accessible and clean multi-agent orchestration has become in Python.

Future Ideas

Live Search Tool Integration: Connecting Google Search grounding or SerpAPI to pull real-time e-commerce links and stock availability.
Group Gift Mode: Splitting a high-ticket budget across multiple contributors with automated per-person share calculations.

AI-Powered Calming Audio & Voice Companion for Dogs Home Alone

Malawige Inusha Thathsara Gunasekara — Sat, 15 Aug 2026 20:19:59 +0000

This is a submission for Weekend Challenge: Dog Days Edition

What I Built

Over 70% of dogs suffer from some degree of separation anxiety when their owners leave for work, errands, or travel. Symptoms include frantic barking, whining, pacing, destructive chewing, and prolonged stress spikes. Standard pet playlists on streaming platforms are static, repetitive, and lack the familiar reassurance pets crave most: their human's voice.

Paws & Peace is an intelligent, multi-platform sensory comfort system designed to give pets a peaceful home-alone experience. Available as both a modern web app and a native Android application, it combines:

Personalized AI & Owner Voice Loops: Using ElevenLabs AI Voice Synthesis, pet parents can generate warm, soothing voice messages with their pet's name, customized reassurance phrases, and fine-tuned stability and clarity. Owners can also record their real voices directly in the built-in Voice Studio.
Layered Procedural Soundscapes: Real-time synthesized pink-noise rainfall (to mask sudden doorbell and traffic sounds), a rhythmic maternal heartbeat simulator (60–70 BPM), and 432Hz harmonic drone frequencies scientifically proven to lower canine heart rates.
Intelligent Departure & Interval Loops: Paced session scheduler with configurable departure delays (e.g., starts 5 minutes after leaving) and recurring voice reassurance (e.g., repeating loving phrases every 3 minutes).
Biofeedback Breathing Visualizer: Luminous multi-ring ripple visualizer paired with live equalizers to create a tranquil visual atmosphere.
One-Tap Smart Presets: Instant audio mixes tailored for Thunder Shield, Bedtime Lullaby, Leaving Home, and Quick Nap.

Demo

Live Web Application: https://weekend-challenge-dog-days-edition-phi.vercel.app
Android Native APK: Download v2.0.0 APK

Web & Mobile Experience:

Web App: Glassmorphic, dark-mode responsive dashboard with Web Audio API procedural sound synthesis and Web Speech API fallback.
Android App: Native Jetpack Compose UI with AndroidX Media3 background foreground service that keeps soothing pets uninterrupted even when the device screen is locked.

Code

GitHub Repository: https://github.com/inusha-thathsara/Weekend-Challenge-Dog-Days-Edition---Home-Alone-Playlist

How I Built It

Building a truly effective sensory companion for dogs required blending canine psychoacoustics with modern cross-platform engineering.

1. Deep Integration with ElevenLabs AI Voice Synthesis

Voice is the strongest comfort cue for a dog. We integrated ElevenLabs' cutting-edge Text-to-Speech API to craft lifelike, warm voice tracks:

Turbo v2.5 Engine (eleven_turbo_v2_5): Upgraded synthesis to the newest ultra-low latency model (<300ms response time) with high throughput and lower credit usage.
Curated Soothing Voice Models: Selected gentle, calming voices (Rachel, Bella, Antoni, Domi, Elli) with adjustable Voice Stability (0.3 – 1.0) and Similarity / Clarity Boost (0.3 – 1.0) to achieve a soft, motherly or gentle fatherly cadence.
Auto-Retry & Rate Limit Handling: Implemented exponential backoff retry logic that catches burst rate limits (HTTP 429), waits 1.5 seconds, and transparently completes generation without failing.
Instant Audio Preview Engine: Embedded MediaPlayer (Android) and AudioContext (Web) previewers that immediately play synthesized tracks so owners can audit tone and volume before leaving.
Compile-Time Build Bridge: On Android, Gradle automatically reads VITE_ELEVENLABS_API_KEY from .env and injects it into BuildConfig, enabling zero-config out-of-the-box synthesis while still allowing user overrides in the Settings dialog.

2. Procedural Audio Synthesis (No Internet / No MP3 Loops)

Instead of streaming heavy, looping MP3 audio files:

Web: Implemented dynamic Web Audio API nodes with continuous pink noise buffers, a low-pass bi-quad filter, and an LFO oscillator for the rhythmic heartbeat.
Android: Engineered a native AudioSynthesizer using AudioTrack and direct PCM byte synthesis. This ensures zero network usage, minimal memory footprint, and infinite non-repeating acoustic variation.
Canine Acoustic Science:
- Pink Noise: Has equal energy per octave ($1/f$ spectral density), which matches canine hearing frequency curves and masks sudden acoustic triggers (thunder, sirens).
- Maternal Heartbeat: Low-pass filtered dual-pulse (lub-dub) at 65 BPM simulating a mother dog's calming presence.
- 432Hz Sine Harmonic: Calibrated sinusoidal frequency associated with parasympathetic nervous system activation.

3. Native Android Architecture (Jetpack Compose & Media3)

UI & Design System: Built with 100% Jetpack Compose and Material 3, featuring glassmorphism, responsive 50/50 segmented tab controls, custom equalizers, and glowing gradient action buttons.
Background Foreground Service: Implemented PlaybackService powered by androidx.media3.exoplayer and MediaSessionService. This ensures that even when the owner locks the phone or puts it on the counter, the soothing playlist continues running indefinitely with interactive lock-screen media controls.
State Management: Built on unidirectional Data Flow with HomeViewModel, Kotlin Coroutines, StateFlow, and Jetpack Preferences DataStore for instant persistence of pet profiles and voice preferences.

Built for dogs everywhere who deserve peace and comfort while waiting for their best friends to come home.

Production AI Dog Breed Identifier & Care Guide

Malawige Inusha Thathsara Gunasekara — Sat, 15 Aug 2026 17:38:43 +0000

This is a submission for Weekend Challenge: Dog Days Edition

Have you ever looked at a dog at the park or in an adoption shelter and wondered: "What breed is that, and what kind of care does it need?"

Meet BreedSnap, a production-grade, full-stack canine intelligence web application powered by Google Gemini Multimodal Vision AI. With just a single photo, BreedSnap instantly identifies the dog breed, scores temperament and energy traits, generates a veterinary-grade care guide, and lets you download a verified PDF breeding report with one click.

What I Built

BreedSnap transforms any canine photo into an actionable, comprehensive genetic and breed profile.

Instead of returning a simple text label, BreedSnap delivers a complete companion intelligence profile:

Instant Canine Visual Recognition: Snap a live photo using your phone's camera, drag and drop files from desktop, or test instantly with one-click canine presets (Golden Retriever, Siberian Husky, Pembroke Welsh Corgi).
Deep Breed & Heritage Breakdown: Pinpoints official breed names, historical origins, and confidence ratings with ~99% match accuracy.
5-Factor Trait & Temperament Scoring: Visual 5-point rating bars for:
- Energy Level
- Trainability & Intelligence
- Family & Child Friendliness
- Grooming Demand
- Barking Tendency
Veterinary Care Guide & Health Watchlist: Provides tailored daily exercise routines, coat maintenance frequency, dietary guidelines, adult weight/size specs, life expectancy, and a genetic health watchlist (e.g., hip dysplasia, IVDD, cataracts).
Canine Trivia & Heritage: Uncovers historical folklore and behavioral facts.
Downloadable Official PDF Report: Compiles a print-ready, high-resolution PDF certificate containing the dog's photo, visual rating bars, care matrix, and verification seal.
Voice Pronunciation: Native audio synthesis of complex breed names using the Web Speech API.
Persistent Scan History: Local storage-backed scan drawer allowing users to browse, reload, and re-export past analyses offline.

Demo

Live Application: https://weekend-challenge-dog-days-edition-nine.vercel.app
Source Code Repository: https://github.com/inusha-thathsara/Weekend-Challenge-Dog-Days-Edition---Breed-Identifier

Code

The entire codebase is open-source and available on GitHub:

Repository Link: https://github.com/inusha-thathsara/Weekend-Challenge-Dog-Days-Edition---Breed-Identifier

How I Built It

1. Architecture & Tech Stack

BreedSnap was designed with speed, privacy, and visual excellence in mind:

Frontend: Lightweight Vanilla HTML5, modern CSS3 (custom glassmorphism design system, Outfit & Plus Jakarta Sans typography, smooth micro-animations), and modular ES6+ JavaScript.
Backend API: Node.js & Express with rate-limiting middleware (express-rate-limit) to prevent API abuse and securely isolate the Gemini API key from the browser.
Serverless Ready: Native Vercel Serverless Functions (/api/identify.js, /api/status.js) and vercel.json for 1-click zero-config cloud deployments.
AI Vision Engine: Google Generative Language API (Gemini 3.1 Flash / Gemini 3.7 Flash).
PDF Engine: Client-side document compilation with html2pdf.js and CSS print media stylesheets (@media print).

2. Prompt Engineering & Structured Gemini Vision

To ensure consistent veterinary outputs, Gemini is guided with structured system instructions and responseMimeType: "application/json":

const prompt = `You are a world-class veterinarian and canine genetics expert. Analyze this dog photo carefully.
Respond strictly with valid JSON only (no markdown fencing, no backticks, no explanatory comments).

If the image clearly contains a dog, return:
{
  "isDog": true,
  "breed": "Official breed name (e.g. Golden Retriever, French Bulldog)",
  "confidence": "High (98%) / Medium (85%) / Low (60%)",
  "origin": "Country / Region of origin",
  "summary": "Engaging 2-3 sentence overview of this breed's character and heritage.",
  "temperament": ["Trait 1", "Trait 2", "Trait 3", "Trait 4"],
  "size": "Size category and typical adult weight range (lbs & kg)",
  "lifespan": "Typical life expectancy in years",
  "ratings": {
    "energyLevel": 1-5,
    "groomingDemand": 1-5,
    "trainability": 1-5,
    "childFriendliness": 1-5,
    "barkingTendency": 1-5
  },
  "careGuide": {
    "exercise": "Recommended daily exercise schedule and activity types",
    "grooming": "Coat maintenance and grooming frequency",
    "nutrition": "Dietary requirements or sensitivities",
    "healthWatchlist": "Common genetic health conditions to monitor"
  },
  "funFacts": [
    "Fascinating historical or behavioral trivia item 1",
    "Fascinating historical or behavioral trivia item 2"
  ]
}

If the image does NOT contain a dog:
{
  "isDog": false,
  "message": "A friendly, witty description of what is actually visible in the image."
}`;

3. Resilient Multi-Model Fallback Cascade

To guard against high-demand traffic spikes and quota limits, the backend implements an automatic fallback cascade across Gemini models:

gemini-3.1-flash-lite (ultra-fast latency & high throughput)
gemini-3.7-flash (deep multimodal reasoning)
gemini-3.5-flash (high-capacity fallback)

If any model encounters high demand or temporary unavailability, the request seamlessly transitions to the next model without failing the user experience.

4. Official PDF Report Generation

Rather than a simple screenshot, clicking Download PDF Report dynamically constructs a high-resolution, branded certificate offscreen, formatting:

The analyzed dog's photo
Official breed title & match badge
Visual 5-star trait rating bars
3-column care guide matrix
Health watchlist alert box
Official diagnostic verification stamp

What's Next for BreedSnap?

Multi-Dog Detection: Identifying and segmenting multiple dogs in a single group photo.
Mixed Breed Percentage Estimator: Estimating heritage percentages for rescue and cross-breed dogs.
PWA Support: Full offline caching with installable mobile home-screen capabilities.

Thank you for reading! Feel free to check out the live demo and share your feedback in the comments.

Building an Adjarian Khachapuri in Pure CSS

Malawige Inusha Thathsara Gunasekara — Sat, 15 Aug 2026 15:44:58 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art.

Inspiration

My comfort-food inspiration for this project was Adjarian khachapuri, the iconic Georgian cheese bread with a golden crust and a molten egg yolk resting in the center. It feels like a warm, homemade hug: rich, cozy, and deeply comforting. I wanted to recreate not just the look of the dish, but the feeling of it being fresh from the oven.

I love how food can be a story in itself, and this challenge gave me a chance to turn a favorite comfort dish into a tiny scene built entirely with HTML and CSS. The goal was to capture the softness of the cheese, the warmth of the crust, and the playful glow of the yolk through gradients, shadows, and subtle motion.

Demo

This project is a pure CSS illustration of an Adjarian khachapuri, built with layered shapes and gradients rather than external images or assets.

Live demo: GitHub repository

If you want to view it locally, just open the project in a browser and interact with the yolk to trigger the jiggle animation.

Journey

This project started as a simple challenge: create a food illustration using only CSS. I quickly realized that the real magic was in the details. The crust needed warmth and depth, the cheese needed softness and texture, and the yolk needed to feel glossy and slightly luxurious without relying on any images.

I spent most of my time refining the gradients and shadows to give the khachapuri a more realistic, premium look. The crust is built with warm browns and highlights to mimic baked dough, while the cheese uses soft ivory tones and subtle highlight bubbles to create a melted, creamy effect. The yolk is the focal point, and I added a small jiggle animation so the composition feels alive and playful.

One thing I’m especially proud of is the way the illustration still feels simple and clean even with the detailed shading. It stays very CSS-first, but it has enough contrast and texture to feel like a polished food shot.

I also learned how much personality can come from small design choices: the steam, the shadow beneath the board, the wobble of the bread, and even the tiny highlights on the cheese. These details make the illustration feel warm and appetizing rather than rigid or flat.

This project reminded me that CSS art is not just about drawing shapes. It is about crafting emotion. A comfortable, believable composition can do a lot with color, depth, and motion alone.

I hope to keep exploring more food-themed CSS illustrations in the future, especially ones that focus on texture and storytelling. It has been a really fun way to combine design, illustration, and front-end development.

Thanks for reading, and if you love warm comfort food as much as I do, I hope this little khachapuri made you smile.

Building a 60fps Scroll-Driven Showcase with Vanilla HTML, CSS, and GSAP

Malawige Inusha Thathsara Gunasekara — Fri, 14 Aug 2026 09:02:05 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, Perfect Landing

What I Built

For this challenge, I built A World of Warmth, an editorial, scroll-driven landing page and mythic codex celebrating comfort food as a universal language of love, nostalgia, and human connection. Rather than creating a standard restaurant site or commercial meal-delivery platform, I wanted to craft an immersive digital publication that treats comfort food not merely as sustenance, but as "history served hot." The experience begins with a full-viewport hero scene bathed in warm candlelight and ambient tones, setting an intimate, candlelit tone that invites visitors to embark on a culinary journey across six continents.

To capture this spirit, the landing page is structured into six full-bleed chapter stories featuring Japanese Tonkotsu Ramen, American Baked Mac & Cheese, Indian Dal Khichdi, French Pot-au-Feu, West African Party Jollof Rice, and Mexican Pork Tamales. Each chapter weaves together origin lore, flavor profiles, and rich imagery, paired with a word-by-word scroll manifesto and an interactive infographic breaking down the real neuroscience behind why comfort food makes us feel so safe and happy.

Demo

Click on above image for the Demo. 🔝

Source Code: Github

Journey

My journey building A World of Warmth began with a clear goal: to avoid creating a simple minimum viable product and instead engineer a complete, magazine-quality web experience that wows users visually while delivering rock-solid frontend fundamentals. Throughout the development process, I learned invaluable lessons about orchestrating complex scroll-driven animations and balancing hardware-accelerated motion with robust fallback systems. Integrating GSAP ScrollTrigger taught me how to fine-tune scroll scrubbing, word-by-word text color reveals, and multi-layered image parallax without triggering layout thrashing or dropping frames. What I am most proud of in this project is the seamless fusion of high-end visual polish with lighthearted, creative storytelling. Watching the project transform from a visual editorial landing page into an interactive Mythic Recipe Codex where clicking a card reveals absurd data like 4,000-year-old eclipse bones and 420-lightyear cook times brought an unexpected layer of joy and humor to the user experience.

Thank You!

Translating Culinary Comfort into Pure CSS Art

Malawige Inusha Thathsara Gunasekara — Fri, 14 Aug 2026 07:45:45 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art.

Inspiration

Ramen is the ultimate universal comfort food: rich, layered, and crafted with meticulous attention to detail. This project set out to translate that directly into front-end architecture. Inspired by the cozy ambience of traditional Japanese ramen counters, Midnight Ramen Bar channels complex CSS gradient math, 3D transform matrices, and keyframe turbulence into a living work of digital art. By replacing every pixel of traditional image assets with native CSS vectors, the artwork bridges the gap between technical precision and pure visual comfort.

Demo

inusha-thathsara.github.io

Journey

Building Midnight Ramen Bar started with a challenge: create a photorealistic artwork using zero raster images. I deconstructed a physical bowl of ramen into distinct optical layers: ceramic bowl geometry, broth depth, submerged noodles, oil beads, artisanal toppings, and rising steam clouds.

Every texture was constructed using pure CSS primitives. Finally, I added a lightweight JavaScript presentation layer for 3D mouse parallax tracking , dynamic room lighting switches, and a live CSS wireframe inspector.

I plan to expand this into a full CSS Comfort Food Collection (like a steaming stack of pancakes with melting butter or a hot slice of pie), explore CSS Houdini Paint Worklets for procedural textures, and build an interactive 3D culinary customizer.

Thank You!

Deconstructing the 2026 Maritime Chokepoint Crisis With a Prioritized SWOT Framework

Malawige Inusha Thathsara Gunasekara — Sat, 18 Jul 2026 18:12:38 +0000

Geopolitical volatility isn't just a headline—it is a brutal stress test for global supply chains. When critical maritime chokepoints face sudden closure, the cascading disruptions hit transshipment hubs with unforgiving speed.

As part of our submission for the INFINITY 7.0 Inter-University Case Study Competition, our team, Case Closed, dived deep into a high-stakes scenario: The 2026 Global Maritime Disruption & Sri Lankan Port Capacity Crisis.

Here is a look at the data, the bottlenecks we uncovered, and the architectural recommendations we proposed to future-proof regional port infrastructure.

1. The Anatomy of the Disruption

The baseline architecture of global shipping relies heavily on the hub-and-spoke model. However, the fatal flaw of this model is its vulnerability to single geographic chokepoints.

When the Strait of Hormuz (which handles roughly 20% of the world's oil and LNG) and the Red Sea/Suez Canal route face severe restrictions or closures, the maritime network experiences immediate systemic shock:

Massive Physical Rerouting: Ocean carriers are forced to divert around the Cape of Good Hope, adding 10 to 15 days of transit time per voyage.
Asset Stranding: These extended transit times trap critical equipment (vessels and empty shipping containers) in transit, triggering an acute global container shortage.
The Transshipment Influx: Rerouted cargo suddenly shifts toward alternative hubs like Colombo, Singapore, and Jebel Ali, pushing their operational capacities to the absolute limit.

2. The Bottleneck: Colombo's Capacity Crisis

When Middle East chokepoints restricted traffic, the Port of Colombo experienced a massive, sudden demand surge, seeing a 20% volume growth within a tight February-to-April window, hitting over 761,000 TEUs in a single month.

This sudden volume spike exposed critical infrastructure vulnerabilities:

[Global Disruptions] ──> [Sudden Rerouting to Colombo]
                                │
                                ▼
               [Transshipment Exceeds 80% of Ops]
                                │
                                ▼
                  [Extreme Yard Overcrowding]
                                │
                                ▼
              [2-3 Day Berthing Delays for ULCVs]
                                │
                                ▼
             [Carriers Begin Bypassing the Port]

With transshipment exceeding 80% of total operations, the physical yard space reached maximum inelasticity. The resulting 2-to-3-day berthing delays meant global carriers began completely bypassing the port, risking Colombo's long-term competitive position.

3. The Analytical Framework: Prioritized SWOT

Instead of relying on a standard, text-heavy SWOT matrix, we utilized a Prioritized SWOT and Matrix Strategy to weigh impacts mathematically and determine which moves yielded the highest strategic ROI.

Matrix Quad	Strategy Focus	Implementation Framework
SO Strategy	Expand Land Bridges	Leverage global fleet adaptability to scale multi-modal overland routes (e.g., the Saudi Landbridge) to bypass maritime blockades.
WO Strategy	Accelerate Green Transition	Shift toward sustainable maritime fuels and dual-fuel vessels to buffer against volatile fossil fuel pricing and emergency bunker surcharges.
ST Strategy	Agile Fleet Rerouting	Permanently optimize Cape of Good Hope alternative routing paths to eliminate total logistical paralysis during multi-chokepoint closures.
WT Strategy	Abandon Just-In-Time (JIT)	Move aggressively away from lean inventory models, increasing safety stocks and diversifying supply chains away from high-risk zones.

4. Engineering a Resilient Logistics Ecosystem

To solve physical bottlenecks, a port cannot rely solely on expanding concrete footprint; it must optimize its digital and logical infrastructure. We proposed six core architecture upgrades for the regional maritime ecosystem:

⚡ 1. Fully Digital "Single Window" Customs

Eliminating paper silos by creating a unified API-driven clearing platform. Digitizing documentation removes friction before the cargo even hits the yard.

🤖 2. Scale Terminal Automation & AI Scheduling

Implementing AI-driven dynamic scheduling to handle inter-terminal transfers. Automated crane deployments and predictive yard slotting allow the port to maximize its existing footprint even under heavy stress.

🌐 3. Build a Multi-Port Ecosystem

Actively diverting excess container and RoRo (Roll-on/Roll-off) traffic south to Hambantota Port. Treating national ports not as isolated competitors, but as a load-balanced network, allows the region to absorb massive volume spikes without failing entirely.

Conclusion: Moving Past "Just-In-Time"

The core takeaway from this case study is clear: Lean inventory systems are incredibly fragile. In an era of increasing geopolitical and climate instability, supply chain architecture must pivot from Just-In-Time efficiency to Just-In-Case resilience. By embracing terminal automation, regional port collaboration, and data transparency, logistics hubs can convert a global crisis into a massive operational opportunity.

We are proud to share that this framework secured our team a spot in the upcoming round of **INFINITY 7.0! If you're working in supply chain tech, logistics optimization, or AI-driven scheduling, I’d love to connect in the comments and hear how you approach system resilience.

🔗 View our full presentation slide deck here

Reverse-Engineering an Old Node.js Crossword App into a Modern Next.js Stack

Malawige Inusha Thathsara Gunasekara — Mon, 22 Jun 2026 15:30:39 +0000

As an IT undergrad at the University of Moratuwa, I’ve built my fair share of projects. Recently, I looked back at an old project of mine—a traditional Node.js Crossword App and realized it was time for a complete teardown.

The old app worked, but the architecture felt dated. I wanted to modernize it, improve the performance, and implement a cleaner, editorial-style UI. Instead of just refactoring, I decided to reverse-engineer the core logic of my own app and rebuild it from the ground up using Next.js 16, Neon PostgreSQL, Better Auth, and v0 by Vercel.

Here is how I broke down the legacy system and engineered the new application, Crosshatch. You can check out the live deployment here: crossword-web-app.vercel.app

The Teardown: Reverse-Engineering the Core Loop

When reverse-engineering an existing app—even your own—the goal is to separate the underlying business logic from the legacy plumbing. I ignored the old routing and view layers and focused entirely on the data structures and the game loop.

I identified three critical systems that needed to be extracted and modernized:

Grid Generation: How words intersect and fit into a 10x10 matrix.
State Management: Tracking user input, active cells, and directional navigation (Across vs. Down).
Session & Progress: How to persist a user's progress without hammering the database.

Once I had the core logic mapped out, I started the rebuild.

Accelerating the UI with v0

I wanted the new app to have a calm, newspaper-inspired light theme. To move fast, I leveraged v0 by Vercel to generate the initial React components.

By prompting v0 with my required game state constraints (e.g., handling keyboard events like Tab, Shift+Tab, and arrow keys for navigation), I was able to rapidly prototype the 10x10 interactive grid. v0 handled the Tailwind CSS boilerplate, allowing me to focus on wiring up the complex state machine using a custom useCrossword React hook.

The Modern Stack & Architecture

With the UI taking shape, I built out a robust backend architecture to support it.

Framework: Next.js 16 (App Router)
Database: Neon PostgreSQL with Drizzle ORM
Authentication: Better Auth (handling secure email/password flows and session management)

Here are the key technical problems I had to solve during the rebuild:

1. Deterministic Puzzle Generation

In the old app, puzzle generation could be unpredictable. For the new build, I implemented a Seeded RNG algorithm. By using the puzzle's ID (e.g., animals-1) as the seed, the generation is completely deterministic. It shuffles the word list, places the first word at (0,0), and maps intersecting cells. If you and a friend both load animals-1, you are guaranteed to get the exact same layout.

Because generating a puzzle is CPU-intensive, I implemented a caching layer. The server generates the puzzle once, caches it in a Map, and serves it instantly on subsequent requests.

2. Smart Autosave & The Visibility API

Losing crossword progress is frustrating. I built a system that autosaves every 5 seconds. To prevent excessive database writes, I used a PostgreSQL UPSERT pattern via Drizzle:

INSERT INTO puzzle_progress (userId, puzzleId, entries, elapsedSeconds)
VALUES ($1, $2, $3, $4)
ON CONFLICT (userId, puzzleId)
DO UPDATE SET entries = $3, elapsedSeconds = $4, updatedAt = now()

Additionally, the puzzle timer uses the browser's Visibility API. If you switch tabs, the timer automatically pauses, ensuring your "Solve Time" stats remain accurate to your actual active playtime.

3. Data Integrity: The "No Double-Credit" Problem

I built a user dashboard to track completions, best times, and average solve times. But what happens if a user submits the same completed puzzle twice?

Instead of writing complex application-level checks, I let the database handle it. I added a unique constraint on (userId, puzzleId) in the completion table and utilized the ON CONFLICT DO NOTHING clause. If a user solves a puzzle for the first time, it records their time. If they re-submit it, the database ignores the insert, returning a response that acknowledges the correct answers without skewing their dashboard analytics.

Final Thoughts

Reverse-engineering an older project and rebuilding it with modern tooling is one of the best ways to measure your growth as a developer. By moving to Next.js and leveraging v0 for rapid UI prototyping, I was able to spend my time solving actual engineering problems (like deterministic generation and state synchronization) rather than wrestling with basic CSS.

Check out the live app at crossword-web-app.vercel.app and let me know what you think of the architecture! I’m always open to technical feedback.

Stop Funding History: Building a Demand Prediction App to Optimize Trade Spend

Malawige Inusha Thathsara Gunasekara — Mon, 22 Jun 2026 15:00:24 +0000

Let’s be honest: in the FMCG (Fast-Moving Consumer Goods) space, trade marketing budgets are almost always misallocated. Companies tend to fund invoice history rather than actual potential.

For the DataStorm 7.0 competition, our team, Stack Kings, decided to stop guessing and start modeling latent demand. We built an analytics pipeline and a Next.js field app to optimize a LKR 5M trade spend across 20,000 retail outlets in Sri Lanka. Here is the unvarnished breakdown of how we achieved a +253% lift over a naive budget allocation.

The "Empty Shelf" Problem (Right-Censoring)

The core data science issue here is a concept called right-censoring. The monthly sales volumes we observed in the 2.3M transaction records were just a lower bound. If a small shop shows low sales, it might just be under-stocked or credit-constrained, not lacking in customer demand.

Because of this, standard averages systematically underestimate a shop's true potential. Instead of using standard textbook models like Tobit—which require strict indicators of exactly when a shop ran out of stock (which we didn't have)—we built an ensemble model.

We took a two-pronged approach:

Lookalike Clustering: We clustered similar outlets to see what the top performers in that specific group were achieving, assuming that less-constrained shops reveal the true ceiling.
Upper-Tail Regression: We used a specific type of regression (Quantile Regression) designed to estimate the maximum possible demand based on a shop's features, rather than the average.

Taking the maximum of these two estimates ensured we weren't artificially pulling down a shop's potential.

Mapping the Real World (Spatial Features)

To give the models a real signal, we engineered spatial features using OpenStreetMap Points of Interest (POIs).

Rather than using arbitrary "flat disk" counts—like just counting how many shops are within a 3km radius—we implemented a distance-decay model. In plain English: a bus stop 200 meters away matters a lot more to foot traffic than one 2 kilometers away.

We grouped locations into tiers. Transport and food places have a "fast" drop-off in influence, meaning you need to be right next to them to get the benefit. Meanwhile, schools and temples cast a wider, "slower" net of influence over the entire neighborhood.

Squeezing Every Drop of Budget (The Optimizer)

Ranking outlets by potential isn't enough; you need to maximize the incremental liters gained per rupee spent.

We modeled the volume response to trade spend as a curve with diminishing returns. Simply put, the more you spend on a single shop, the less extra volume you get for your next rupee.

To solve this efficiently across 9,000 Western Province outlets, we broke that curve into straight-line segments. This allowed us to use a Linear Programming solver to allocate the LKR 5M budget mathematically perfectly. The result? A massive 253% lift compared to the standard gut-feel approach of just splitting the money evenly among top shops.

Building Trust with the Field App

stackkings.inusha.me

A complex optimizer is useless if field sales reps don't trust the numbers. They need to know why a shop is getting a certain budget.

We built a live Outlet Intelligence Web App using Next.js and Postgres. To explain the outputs, we added an Explainable AI (XAI) layer. It uses a local Ollama process (gemma3:1b) running in the browser to generate a structured SWOT summary. If the local AI is offline, it falls back to a Gemini cloud API or a safe deterministic template.

Crucially, the AI doesn't make the predictions. It simply translates our hard, pre-computed data into plain business language so the sales reps can actually use it on the ground.

The Dirty Reality of Data

Data engineering isn't glamorous. We built a strict Medallion architecture. We didn't silently drop messy data. We explicitly quarantined 37,205 records using failure reason codes. We even retained 7,417 "blackout" outlets (shops with zero December transactions), treating them correctly as supply signals rather than zero demand.

Check out the live production app at stackkings.inusha.me

We don't fund history. We fund potential.

DEV Community: Malawige Inusha Thathsara Gunasekara

Building an Enterprise Climate Intelligence OS

How We Won 1st Place at CodeFest Datathon 2026: Building an Enterprise Carbon Intelligence OS

The Macro Problem: Carbon is a Balance Sheet Liability

Breakthrough 1: Why Classical ARIMA Crushed Machine Learning on Carbon Prices

The Battle: ARIMA vs. Gradient Boosted ML

Why Did Classical Econometrics Win?

Breakthrough 2: Teaching Machine Learning the Laws of Chemistry

Domain-Driven Feature Engineering

Benchmark Results (5-Fold Cross-Validation, 80/20 Test Split)

Breakthrough 3: Rejecting the Null Hypothesis (H₀)

The Weekend Data Trap Most People Miss

Cumulative Abnormal Returns (CAR) Event Study

The Verdict: Directional Movement Lift Across ALL 5 Markets

Breakthrough 4: Uncovering 2030 Sovereign Transition Archetypes

The Interactive Web MVP: Live Demonstration

Core MVP Capabilities:

The Commercial Strategy: Pitching for the Win

5 Lessons for Winning Datathons and Hackathons

From 48M Records to Top 8 Finalists: How We Built an End-to-End Urban Flow AI

🎥 The 4-Minute Walkthrough

🏗️ High-Level System Architecture

1. Taming 48.6 Million Records Without Running Out of Memory

Chunked Streaming Ingestion

The "Speed Trap" and Temporal Anomaly Cleaning

2. Preventing Data Leakage (The Competition Trap)

Chronological Holdouts vs. Random Splits

Pre-Trip Only Features

3. The Supervised Modeling Tournament

Why Gradient Boosting Triumphed

4. Spatio-Temporal Forecasting & Origin-Destination Corridors

Autoregressive Lag-Based Forecasting

4 Time-Slice OD Flow Clustering

5. From Raw Code to Executive Decision-Making

1. The Conversational AI Mobility Assistant

2. The $51.8M ROI Financial Model

6. Four Lessons That Helped Us Secure the Top 8

🏁 Looking Forward to the Finals!

I Tackled the Planet of Lana Language Challenge by Building an AI Translator & Voice Synthesizer

1. Deconstructing Novo Terali: The Lore & Linguistics

Morphological Patterns Discovered:

2. Architecture Overview: Local-First Meets Cloud-Native

3. Challenge #1: Hallucination Prevention in Conlang Extrapolation

4. Challenge #2: The Anti-Gibberish Quarantine Guard

5. Challenge #3: Giving Lana a Voice with Acoustic Tuning

6. Deployment & Cloud Hardening

7. The Result: Taking the Challenge to the Stars

Example 1: Canonical Dialogue Match

Example 2: Complex Extrapolated Expression

Try It Out!

Multi-Agent Gift Recommendation Engine Powered by Google ADK & Gemini

Live Demo & Links

What I Built

Key Highlights & Features

Cloud Run Embed

1. Profile Analyzer Agent (ProfileAnalyzerAgent)

2. Idea Finder Agent (IdeaFinderAgent)

3. Budget Filter Agent (BudgetFilterAgent)

4. Orchestration with SequentialAgent

Implementation & Architecture

Backend Tech Stack

Cloud Run Production Optimization

Key Learnings

Conclusion & What's Next

Future Ideas

AI-Powered Calming Audio & Voice Companion for Dogs Home Alone

What I Built

Demo

Web & Mobile Experience:

Code

How I Built It

1. Deep Integration with ElevenLabs AI Voice Synthesis

2. Procedural Audio Synthesis (No Internet / No MP3 Loops)

3. Native Android Architecture (Jetpack Compose & Media3)

Production AI Dog Breed Identifier & Care Guide

What I Built

Demo

Code

How I Built It

1. Architecture & Tech Stack

1. Profile Analyzer Agent (`ProfileAnalyzerAgent`)

2. Idea Finder Agent (`IdeaFinderAgent`)

3. Budget Filter Agent (`BudgetFilterAgent`)

4. Orchestration with `SequentialAgent`