DEV Community: Kevin Coto🚀💡

Building a LINE First Fitness Agent with AI Cost Gates

Kevin Coto🚀💡 — Wed, 15 Jul 2026 01:04:49 +0000

A Polyglot Feedback Platform: Django, Next.js, and Elixir Working Together

Kevin Coto🚀💡 — Wed, 15 Jul 2026 01:03:53 +0000

Building an AI Accountability Coach That Knows Your Habits

Kevin Coto🚀💡 — Wed, 15 Jul 2026 01:03:50 +0000

Building a Multi Platform AI Budget Coach

Kevin Coto🚀💡 — Wed, 15 Jul 2026 01:03:20 +0000

Building a Voice AI Receptionist for Restaurants

Kevin Coto🚀💡 — Wed, 15 Jul 2026 01:03:18 +0000

Building a Reusable Chat Infrastructure with DynamoDB Single Table Design

Kevin Coto🚀💡 — Wed, 15 Jul 2026 00:51:11 +0000

Designing a Three Reviewer Consensus Platform for Digital Harm Reporting

Kevin Coto🚀💡 — Wed, 15 Jul 2026 00:50:41 +0000

Building a Real Time Sports Scoring Engine with WebSockets and DynamoDB Streams

Kevin Coto🚀💡 — Wed, 15 Jul 2026 00:49:11 +0000

Migrating a Production Platform from CDK to SST Without Downtime

Kevin Coto🚀💡 — Wed, 15 Jul 2026 00:48:21 +0000

From Dubai to Thailand: How I Landed a Remote Role at a South African Company

Kevin Coto🚀💡 — Wed, 15 Jul 2026 00:28:06 +0000

The Next Chapter

When I left the waiter job and returned to engineering, I knew I wanted something different. Not just a different job, but a different way of working. The kind where your location does not limit the problems you can solve.

I found that in Thailand, working for a South African company called Exonic.

Why Bangkok

After Dubai, I wanted somewhere with a lower cost of living where I could build runway while working remotely. Bangkok checks that box. The city is a hub for remote engineers. The internet is fast. The infrastructure works. The street food is better than any restaurant I have ever worked in.

I arrived with a laptop and a clear goal: find a remote role where I could work on meaningful projects without being tied to a physical office.

Landing the Role at Exonic

Exonic is a technology consulting company based in South Africa. They serve clients across multiple industries and geographies. When I found the opening, it matched exactly what I was looking for: full time remote, exposure to diverse projects, and the chance to work across the full stack.

The interview process was practical. System design discussions, technical assessments focused on AWS and modern frontend frameworks, and conversations about how I approach end to end delivery.

I got the offer and accepted it immediately.

As a full time remote employee, I was embedded in Exonic's engineering team. My day to day involved building cloud native solutions for their clients, designing architectures on AWS, and shipping production systems across the entire stack. The team was distributed, and the work required communicating clearly across time zones.

Three Continents Through One Company

Exonic's client base spans the globe. Over my time there, I built production systems touching three different continents.

One project was Scoring AI, a voice enabled match scoring application for sports courts. Players start a match, share a link, and control the scoreboard using voice commands. I worked on the full stack: the real time scoring engine, voice command processing, the shareable match link flow, and the responsive display that works on phones, tablets, and court side screens. The stack was Svelte on the frontend with a Node backend deployed on AWS.

Another project was My IBD Pal for Ferring Malaysia, a healthcare application for patients with inflammatory bowel disease. This involved building patient facing interfaces and clinical backend systems, processing health data securely, and integrating with healthcare infrastructure in the Malaysian market. The project is protected and not publicly accessible.

I also worked on Real411, a digital complaints platform for Media Monitoring Africa in South Africa. The platform allows citizens to report digital offenses, track complaint status, and supports media regulation workflows. Full stack development, from the submission forms to the admin dashboard and trend analytics. This project is also under restricted access.

Each project had different business contexts, different regulatory requirements, and different user bases. The engineering principles remained the same: understand the domain, design the solution, ship it, document it.

The AWS Solutions Architect Certification

Working across multiple AWS projects for different clients made one thing clear: I needed a formal credential that backed up the experience. The AWS Solutions Architect certification is the industry standard for cloud architecture knowledge.

I studied for six weeks. Not because the material is difficult, but because the scope is wide. Compute, storage, networking, databases, security, cost optimization. Each domain has multiple services and multiple trade offs.

The exam is scenario based. You are given a business requirement and you choose the architecture that meets it. Not just which service, but why. The certification forces you to think in trade offs: cost versus performance, latency versus durability, managed versus self hosted.

Passing it validated the patterns I had been applying in production for Exonic's clients. The theory matched the practice.

End to End Ownership

One of the best parts of the role was the scope. Exonic trusted me with full projects, not just isolated tickets.

An end to end project looked like this:

Discovery. Understand the business domain. What problem are we solving? Who are the users? What are the constraints?
Architecture. Choose the stack and design the system. Document the rationale.
Implementation. Build it. Write tests. Set up CI/CD.
Deployment. Put it in production. Configure monitoring and alerts.
Handoff. Document everything. Train the team. Transfer ownership.

The AWS certification helped with step two. The experience working across different client contexts helped with step one. The discipline of shipping consistently helped with steps three through five.

What Changed

When I was in Cuba, I was a good engineer with limited options. When I was in Dubai working as a waiter, I was someone starting from zero in a new country. When I landed in Bangkok and joined Exonic, I was someone who had learned that the ceiling is not set by your location.

It is set by your ability to deliver.

Employers do not care where you log in from. They care whether the code compiles, the deployments succeed, and the systems stay up. If you can do that consistently, you can work from anywhere.

What I Learned

Full time remote is different from freelancing. Freelancing gives you flexibility. A full time remote role gives you stability, team structure, and exposure to larger projects. Both are valid, but they require different mindsets.

A South African company hiring someone in Thailand to build for clients in Malaysia, South Africa, and beyond is not unusual anymore. Geography is no longer a constraint. The companies that understand this win access to global talent.

Specific projects teach more than generic ones. Scoring AI taught me about real time voice processing on the web. My IBD Pal taught me about healthcare data compliance. Real411 taught me about building for media regulation workflows. Each project expanded my context, not just my tech stack.

Certifications validate what you already know. They are not a replacement for experience. But they make it easier to get past the first screening call.

Full ownership changes how you build. When you own the entire lifecycle, you design differently. You think about deployability from day one. You write documentation as you go. You build systems that do not require you to be on call forever.

I started my career in Cuba. I worked as a waiter in Dubai. I moved to Thailand and joined a South African company building for clients across three continents. The path was not linear, but it was worth it.

Integrating Cloudflare Turnstile with SvelteKit Forms

Kevin Coto🚀💡 — Sun, 30 Mar 2025 15:29:59 +0000

The Problem

Bot protection is essential for any public facing form. Cloudflare Turnstile offers a privacy friendly alternative to traditional CAPTCHAs: no image grids, no traffic analysis, just a lightweight challenge that runs in the background.

When you pair it with SvelteKit's use:enhance for progressive form enhancement, you hit a subtle issue. Turnstile tokens are single use. After a successful submission, the old token is consumed. The next submission attempt fails because the widget still holds the spent token. The page does not reload (that is the whole point of use:enhance), so the widget never gets a chance to issue a fresh one.

This guide walks through a complete SvelteKit integration with server side validation, client side token refresh, and multiple submission support.

Server Side Validation

Turnstile verification must happen on the backend. A client side check alone can be bypassed.

Backend (`+page.server.ts`)

import { SECRET_TURNSTILE_KEY } from '$env/static/private';

async function validateToken(token: string): Promise<boolean> {
  const response = await fetch('https://challenges.cloudflare.com/turnstile/v0/siteverify', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      secret: SECRET_TURNSTILE_KEY,
      response: token
    })
  });
  const data = await response.json();
  return data.success;
}

export const actions = {
  default: async ({ request }) => {
    const formData = await request.formData();
    const token = formData.get('cf-turnstile-response')?.toString() || '';

    if (!token || !(await validateToken(token))) {
      return { success: false, message: 'Verification failed. Please try again.' };
    }

    return { success: true, message: 'Form submitted successfully.' };
  }
};

A few things worth noting here.

Turnstile returns the token as cf-turnstile-response by default. That field name is configurable if you need to avoid collisions.

The siteverify endpoint expects URL encoded form data, not JSON. This is a common gotcha when using fetch with the default JSON content type.

Store the secret key in a .env file as SECRET_TURNSTILE_KEY and reference it through SvelteKit's $env/static/private module. Never expose it to the client.

Frontend Integration

The client side uses the svelte-turnstile package which wraps the Turnstile widget as a Svelte component.

npm install svelte-turnstile

Frontend (`+page.svelte`)

<script lang="ts">
  import { Turnstile } from 'svelte-turnstile';
  import { enhance } from '$app/forms';

  let captchaKey = $state(0);
  let { form } = $props();

  $effect(() => {
    if (form) {
      captchaKey += 1;
      form = null;
    }
  });
</script>

<form method="POST" use:enhance>
  {#key captchaKey}
    <Turnstile siteKey={import.meta.env.VITE_TURNSTILE_SITEKEY} />
  {/key}
  <button type="submit">Submit</button>
</form>

Why the Key Block Works

SvelteKit's use:enhance intercepts the form submission and updates the page without a full navigation. The Turnstile widget holds a token that has now been spent.

The {#key captchaKey} block tells Svelte to destroy and recreate its children whenever captchaKey changes. Incrementing the counter inside the $effect forces a fresh Turnstile widget to mount with a new token.

No setTimeout, no mount/unmount races, just a counter increment.

Environment Variables

You need two keys from the Cloudflare Turnstile dashboard.

VITE_TURNSTILE_SITEKEY=0x4AAAAAA...    # public, exposed to browser
SECRET_TURNSTILE_KEY=0x4AAAAAA...       # private, server only

The VITE_ prefix makes the variable available to client side Vite bundles. The un-prefixed version is loaded through $env/static/private and never leaves the server.

Production Considerations

Token expiry. Turnstile tokens expire after 300 seconds. If a user fills out a long form, the token may become invalid by the time they hit submit. Consider implementing a periodic refresh mechanism for forms with long completion times.

Rate limiting. The /siteverify endpoint does not have built in rate limiting. Implement your own per IP or per session limits to prevent abuse.

Accessibility. Turnstile runs a non interactive challenge by default. If the challenge fails, it falls back to a visible widget. Test this flow with keyboard only navigation and screen readers.

Multiple forms on one page. Each Turnstile instance needs a unique widget ID. The svelte-turnstile component handles this internally, but verify that your page layout does not share instances between forms.

Summary

Turnstile tokens are single use and require a fresh widget after each submission.
Server side validation is mandatory. Never trust the client alone.
The mount/unmount pattern in $effect solves the token refresh problem cleanly.
Environment variables keep your keys separated by environment.

This setup gives you a secure, bot protected form that works with SvelteKit's progressive enhancement.

LeetCode 35: Search Insert Position. Binary Search vs Linear Scan

Kevin Coto🚀💡 — Fri, 14 Mar 2025 19:50:34 +0000

The Problem

Given a sorted array of distinct integers and a target value, return the index where the target would be inserted to maintain order. If the target already exists, return its index.

Input: nums = [1, 3, 5, 6], target = 5
Output: 2

Input: nums = [1, 3, 5, 6], target = 2
Output: 1

Input: nums = [1, 3, 5, 6], target = 7
Output: 4

The problem is straightforward on the surface, but the constraints reveal its intent. The array is sorted, and the operation needs to complete efficiently.

A Linear Solution

A linear scan checks each element until we find the insertion point.

var searchInsert = function(nums, target) {
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] >= target) return i;
  }
  return nums.length;
};

This works but runs in O(n) time. For an array of 10,000 elements, the worst case iterates through all of them. The problem expects a solution that exploits the fact that the input is sorted.

Binary Search

Binary search divides the search space in half at each step. It runs in O(log n) time, which means finding an element in a million entries takes at most 20 comparisons instead of a million.

The algorithm maintains three pointers: left, right, and mid. At each step we check the middle element. If it matches the target, we are done. If the target is smaller, we discard the right half. If larger, we discard the left half.

When the loop ends without finding the target, left points to where the target should be inserted.

var searchInsert = function(nums, target) {
  let left = 0;
  let right = nums.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);

    if (nums[mid] === target) {
      return mid;
    } else if (nums[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return left;
};

Why the Insertion Point Works

When the loop exits, left has crossed right. The element at left is the first element greater than the target (or left equals the array length if the target belongs at the end). This is exactly the insertion position.

The invariant nums[right] < target < nums[left] holds at the point of exit. Visualizing this helps. Try tracing through [1, 3, 5, 6] with target = 2:

Step 1: left=0, right=3, mid=1, nums[1]=3 > 2, go left
Step 2: left=0, right=0, mid=0, nums[0]=1 < 2, go right
Step 3: left=1, right=0, exit loop, return left=1

The index 1 is where 2 fits between 1 and 3.

Edge Cases

Target smaller than all elements. The algorithm returns 0, which is correct.

nums = [10, 20], target = 5
left=0, right=1, mid=0, nums[0]=10 > 5, right=-1, exit, return 0

Target larger than all elements. The loop shifts left past the last index and returns nums.length.

nums = [10, 20], target = 30
left=0, right=1, mid=0, nums[0]=10 < 30, left=1
left=1, right=1, mid=1, nums[1]=20 < 30, left=2
exit, return 2

Single element arrays. The algorithm handles these with no special cases.

nums = [5], target = 3
left=0, right=0, mid=0, nums[0]=5 > 3, right=-1, exit, return 0

Complexity

Approach	Time	Space
Linear scan	O(n)	O(1)
Binary search	O(log n)	O(1)

Binary search matches the problem's constraints and is the expected solution. The space complexity is constant because we only store three integers regardless of input size.

Takeaways

Binary search is one of those patterns that seems trivial on paper but requires careful pointer management in practice. The off by one errors are common. The key is tracking the invariant: the condition for moving left and right must be consistent, and the exit condition must guarantee that left is the answer.

Practice this pattern on a few variations:

Standard binary search (find exact match)
Lower bound (first position where element could be inserted)
Upper bound (last position where element could be inserted)

Each variant adjusts the pointer movement rules slightly. Understanding one makes the others click.

DEV Community: Kevin Coto🚀💡

Building a LINE First Fitness Agent with AI Cost Gates

A Polyglot Feedback Platform: Django, Next.js, and Elixir Working Together

Building an AI Accountability Coach That Knows Your Habits

Building a Multi Platform AI Budget Coach

Building a Voice AI Receptionist for Restaurants

Building a Reusable Chat Infrastructure with DynamoDB Single Table Design

Designing a Three Reviewer Consensus Platform for Digital Harm Reporting

Building a Real Time Sports Scoring Engine with WebSockets and DynamoDB Streams

Migrating a Production Platform from CDK to SST Without Downtime

From Dubai to Thailand: How I Landed a Remote Role at a South African Company

The Next Chapter

Why Bangkok

Landing the Role at Exonic

Three Continents Through One Company

The AWS Solutions Architect Certification

End to End Ownership

What Changed

What I Learned

Integrating Cloudflare Turnstile with SvelteKit Forms

The Problem

Server Side Validation

Backend (+page.server.ts)

Frontend Integration

Frontend (+page.svelte)

Why the Key Block Works

Environment Variables

Production Considerations

Summary

LeetCode 35: Search Insert Position. Binary Search vs Linear Scan

The Problem

A Linear Solution

Binary Search

Why the Insertion Point Works

Edge Cases

Complexity

Takeaways

Backend (`+page.server.ts`)

Frontend (`+page.svelte`)