Google: Gemma 3 4B

Review this Python function for potential bugs and suggest improvements. Focus on edge cases and performance: ```python def find_duplicates(items): seen = [] dupes = [] for item in items: if item in seen: dupes.append(item) seen.append(item) return dupes ```

The function has a critical performance issue: using `item in seen` on a list creates O(n²) complexity. Edge cases to consider: empty lists return correctly, but duplicate duplicates get added multiple times to the result. Suggested fix: use a set for `seen` to achieve O(n) lookup, and use a set for `dupes` initially to prevent duplicate entries in results, then convert to list if needed. Also consider whether you want to preserve order of first occurrence. Type hints would improve clarity: `def find_duplicates(items: list) -> list:`

Demonstrates code review capability with concrete performance analysis. At 4B parameters, Gemma 3 catches the algorithmic inefficiency and suggests the standard set-based solution. The 131K context window isn't tested here, but the response stays focused on the immediate problem rather than over-explaining — appropriate for a smaller model.

I have a CSV with columns: date, product_id, revenue, region. Write a SQL query to find the top 3 products by total revenue in each region for Q1 2024, showing product_id, region, and total_revenue.

```sql WITH quarterly_revenue AS ( SELECT product_id, region, SUM(revenue) as total_revenue FROM sales WHERE date >= '2024-01-01' AND date < '2024-04-01' GROUP BY product_id, region ), ranked_products AS ( SELECT product_id, region, total_revenue, ROW_NUMBER() OVER (PARTITION BY region ORDER BY total_revenue DESC) as rank FROM quarterly_revenue ) SELECT product_id, region, total_revenue FROM ranked_products WHERE rank <= 3 ORDER BY region, rank; ``` This uses a CTE to aggregate quarterly revenue, then window functions to rank within each region.

Shows competence with multi-step SQL logic and window functions. The query structure is clean and the explanation is brief. A 4B model sometimes struggles with complex nested queries, but this example stays within comfortable territory — two CTEs and a straightforward window function. Doesn't explore dialect-specific optimizations.

Explain how OAuth 2.0 authorization code flow works to a junior developer who understands HTTP but hasn't used OAuth before. Keep it under 100 words.

User clicks 'Login with Google' on your app. Your app redirects them to Google with your client_id. User logs in at Google and approves access. Google redirects back to your app with a temporary authorization code in the URL. Your app sends this code plus your client_secret to Google's token endpoint. Google verifies everything and returns an access_token. Your app uses this token in API requests to access user data. The code is single-use and short-lived; the token is what matters for ongoing access.

Tests explanation ability with a technical concept that requires both accuracy and clarity. Gemma 3 4B handles the constraint well — hits the key steps without jargon overload. Multimodal support means it could theoretically process a diagram here, but text-only explanation is appropriate. The 100-word limit is respected, showing instruction-following at the $0.05/Mtok price point.

When Gemma 3 4B handles doc Q&A under $50/month

A 12-person startup needs to query their Notion wiki, Slack archives, and Google Docs without paying OpenAI's per-seat fees. Gemma 3 4B at $0.05/$0.10 per Mtok makes this work: the 131k context window fits most internal docs in a single call, and at typical query volumes (200-400/day), you're spending $30-40/month total. The model handles straightforward retrieval and summarization well enough for internal use, though you'll notice it struggles with nuanced policy questions or multi-step reasoning compared to GPT-4 class models. If your team is asking 'where did we document X' more than 'synthesize these three conflicting sources,' this is the right price-performance point. Route complex queries to a stronger model and keep Gemma 3 4B as your default.

Gemma 3 4B for high-volume product copy at scale

A 6-person Shopify agency writes 2,000+ product descriptions monthly across 15 client stores. Gemma 3 4B's $0.10/Mtok output pricing makes this economically viable: generating 150-word descriptions costs roughly $0.0015 each, so 2,000 descriptions run about $3 in generation costs. The model handles structured input (product specs, brand voice guidelines) and produces serviceable marketing copy that needs light editing rather than full rewrites. You'll see generic phrasing and occasional repetition, but for SKU-heavy catalogs where 80% good-enough beats perfect-but-slow, this works. If you're writing hero copy for landing pages or need brand-voice precision, route those to Claude or GPT-4o. For catalog scale, Gemma 3 4B keeps your margin intact.

When Gemma 3 4B routes 10k tickets/day under budget

A 40-person SaaS company triages 8,000-12,000 support tickets daily into billing, technical, and account categories before human review. Gemma 3 4B at $0.05 input handles this: average ticket length is 200 tokens, so 10k tickets costs $1/day in inference. The model's image support lets it process screenshot attachments for error classification, and the 131k context window means you can include the last 5 customer interactions for better routing accuracy. Classification accuracy sits around 92-94% on straightforward categories, which beats rule-based systems and keeps costs predictable. If you need sentiment analysis or intent detection beyond simple bucketing, you'll want a reasoning-focused model. For high-volume triage where speed and cost matter more than perfect accuracy, this is the call.