Victor Laperuta

· I built the website in Next.js and React: search, shop signup, cart, checkout, account.

· I built the Express and MySQL backend: search with Algolia, payments with Asaas (card and bank slip), SMS with Twilio, push with OneSignal, photos on S3, delivery through a courier API.

· I learned TypeScript and React Native from the senior contractors and took over the app when they left: home, regions, search, shop, product, checkout, payment.

The app, and what was under it

· Screens: home, regions, location, search, shop, product, checkout, payment method, card, login, signup.

· React Native, Redux, OneSignal for push, geolocation for the shops near you.

· Backend: Express on MySQL. Search with Algolia. Payments with Asaas, card and bank slip. SMS with Twilio. Photos on S3. Delivery through a courier API.

· The link a shop shared on WhatsApp opened the same catalogue on the web.

What I did in 2020

· I built the website in Next.js and React: search, shop signup, cart, checkout, account.

· I built the Express and MySQL backend: search with Algolia, payments with Asaas (card and bank slip), SMS with Twilio, push with OneSignal, photos on S3, delivery through a courier API.

· I learned TypeScript and React Native from the senior contractors and took over the app when they left: home, regions, search, shop, product, checkout, payment.

The website

· Next.js with React and Material UI, deployed on Vercel.

· Pages: search, shop signup, cart, checkout, account, help; the merchant side with my sales and product registration.

· An end-to-end suite with Nightwatch, GitHub Actions, and Docker gated the deploys in 2020. It rotted later, which taught me what a test suite costs.

2020, Dolado, my first job as an engineer and the company’s first engineering hire. In March the pandemic closed these shops, and their owners were selling over WhatsApp. We built them a free online catalogue: I built the website and the backend and took over the app.

A shop got a page and a link, shared the link on WhatsApp, and took card or cash at the door. The site is Next.js; the backend is Express and MySQL, with Algolia for search and Asaas for card and bank-slip payments.

Senior contractors started the React Native app, taught me React Native and TypeScript, and left. I took the app over and shipped it: home, search, shop, product, checkout, payment.

That year I also set up the first end-to-end test suite, Nightwatch with GitHub Actions and Docker, gating every deploy. It rotted later, when nobody owned it. Since then I treat a test suite as something that needs an owner and a budget.

Orders went out through the link while the doors stayed shut. When the shops reopened, the company turned to supplying them: what a shopkeeper used to fetch on a trip to 25 de Março, phone accessories first, delivered at the shop door. Next: the B2B marketplace.

· I built the headless storefront: Next.js on the Shopify Storefront API with GraphQL and Apollo, the checkout and the cart left to Shopify.

· I built and maintained the backend: an Express monolith in TypeScript from its first commit, with the request, response and middleware types written by hand, Joi validators, and the integrations: Shopify webhooks, TOTVS (the ERP), Intelipost (shipping), Asaas (payments and Pix), Konduto (fraud).

· I built the data-analysis project on the default: Shopify orders, the credit base, Konduto and the ERP’s customers in pandas; k-means on PCA with silhouette scores, correlation heatmaps and a random forest for feature importance; the credit rules changed from it, the bank slip only after two paid orders and a limit per customer.

· I took the team from JavaScript to TypeScript, gradually, and moved the monolith to NestJS in 2023.

· I wrote the Terraform for the Shopify infrastructure and the CircleCI pipelines that deployed it.

· I onboarded and mentored the engineers who joined the team.

The storefront

· A headless Shopify shop: Next.js on the Storefront API with GraphQL and Apollo, the custom React front the merchants used to order.

· Login through Shopify Multipass; the cart and the checkout stayed in Shopify.

· The Shopify service in NestJS received the webhooks and kept products, stock, and orders in step with the ERP.

The monolith, typed by hand

· Express and TypeScript from the first commit, in March 2021, before NestJS: generic request and response types, typed middlewares and error handlers, Joi validators on every route.

· The work was integration, kept in step both ways: Shopify (products, orders, webhooks), TOTVS for the ERP, Intelipost for shipping, Asaas for payments and Pix, Konduto for fraud checks, Take Blip for WhatsApp.

· A shared validation package, mostly mine, served the fronts and the backends.

· In March 2023 the monolith moved to NestJS; the team moved to TypeScript gradually before that.

The default, and what the data said

· The buy-now-pay-later was a bank slip due in fifteen days. Some accounts were opened to never pay one. Konduto came in for fraud, but took days to approve and delayed orders.

· I put the Shopify orders, the credit base, Konduto’s decisions and the ERP’s customers into pandas: scaling, PCA, k-means with silhouette scores, Pearson, Kendall and Spearman correlations, a random forest for feature importance, radar charts per cluster.

· From it, with others’ input, the credit rules changed: the bank slip only after two paid orders and a credit limit per customer.

The integrations, one by one

· Shopify: the storefront and the checkout. TOTVS: the ERP, stock and invoices. Asaas: payments and Pix.

· Intelipost: shipping quotes and tracking. Konduto: fraud checks on orders. Take Blip: WhatsApp with the shops.

· NF-e, ICMS, SPED: the Brazilian fiscal systems.

2021 to 2023, Dolado: a B2B marketplace where small retailers restocked at wholesale prices from suppliers Dolado negotiated, in one Shopify store of Dolado’s own with a headless Next.js storefront. As de facto tech lead I built the storefront and the backend that kept it all in sync.

The backend was one Express monolith in TypeScript, before I knew NestJS: I typed every request, response and middleware by hand, with little help from the ecosystem. The job was integration: Shopify, the ERP TOTVS, Intelipost for shipping, Asaas for payments, Konduto for fraud, all kept in step.

The hard period: buy now, pay later by bank slip brought a high default rate. Some users opened several accounts and never paid a single order; we had code-red meetings. Konduto came in for fraud, but took days to approve, delayed orders, and the sellers were not happy.

I built a data-analysis project in Python and pandas: customers clustered with k-means on PCA, correlations and a random forest to see what went with default. From it the credit rules changed: the bank slip only after two paid orders, and a limit per customer.

I moved the team to TypeScript, step by step, onboarded the engineers who joined, and moved the monolith to NestJS in 2023. That year the company bought a dropshipping platform, and I became its backend engineer.

· I finished the parent-account model: per-user product rules and custom kits.

· I built one-click listing per marketplace and automated account onboarding with per-step metadata and reprocessing.

· I fixed the NF-e issuance that exhausted the database connections: a refactor across almost every PHP file so each request shares one database instance, separate database credentials per service to see who consumed the connections, RDS tuned with a writer and a read replica, and the wallet balances updated under pessimistic locks with a deadlock retry.

· I added logs and traces to the Cronicle jobs so a failing seller token was visible, the visibility the bought software never had.

· I found an exposed AWS key from an insecure PHP app, killed the rogue instance it had spawned, destroyed the infrastructure that was not ours, traced every exposed key and user in CloudTrail and rotated them.

· I rebuilt error handling and observability: exceptions logged to S3 and Slack instead of swallowed, New Relic on the services, integration problems recorded per seller, shown in the hub and emailed, and threshold dashboards alerting on Slack.

· I moved invoice issuing from the batch cron into the order-status workflow, issued on demand as the order moves, with a second issuer behind a toggle that we built and never switched on.

· I rebuilt the queues in Terraform, each with a dead-letter queue, wrote the worker and ECS Fargate modules, moved the PHP from EC2 to ECS Fargate, moved the rest of the hand-managed infrastructure to Terraform, and automated the Lambda deploys through CI/CD. I abandoned a month-long attempt to move everything to the Serverless Framework as infeasible alone.

The platform, as it was

· API Gateway in front of hundreds of Node.js Lambda functions, roughly one endpoint each: SKUs, orders, hub, subscriptions, companies, users, purchases, carriers, taxes.

· A PHP service, framework-less, on ECS Fargate, holding the sales channels, invoices, carriers, labels, charges, and subscriptions.

· A NestJS service in six environments on Elastic Beanstalk: the API, callbacks, the webhook worker, the worker, payment gateways, invoices.

· Ten SQS FIFO queues, each with a dead-letter queue, rebuilt in Terraform: invoices, NF-e, callbacks, payment gateways, carrier EDI, webhooks, invoice email, stock balance, reports, the worker.

· MySQL on RDS for the ledgers, MongoDB for audits and events, Redis for cache. Cronicle for the jobs. New Relic and Sentry watching.

· Terraform for what had been hand-managed; CircleCI for the deploys.

One order, station by station

· A callback or a webhook from the marketplace puts the order on the queue.

· The order-status workflow: validate the seller’s tax model and the suppliers’, update the wallet, find the NF-e templates, create the invoices, issue them, validate they were issued, close the order, update the SKU balance.

· Picking list, packing, the label (Correios or the carrier’s own), the carrier’s collection list, the EDI files back from the carrier, tracking until delivered.

· The SKU balance goes back to every marketplace listing. The seller’s sales count and the listing’s health are what the marketplace shows for it.

Who the platform talked to

· These integrations came with the acquired software; I adapted and maintained them.

· Marketplaces: Mercado Livre, Shopee, Amazon, Magalu, Americanas, Via, Netshoes, Carrefour, Dafiti, Leroy Merlin, MadeiraMadeira, Olist, Mobly.

· Shops and ERPs: Shopify, VTEX, WooCommerce, Tray, Bling, Tiny, Magento, Loja Integrada, Linx.

· Payments: Asaas, Mercado Pago, Pagar.me, boleto files for the banks. Antifraud with ClearSale.

· Carriers: Correios, Intelipost, Jadlog, Melhor Envio, Mandaê, Total Express and others, with a carrier auction for quotes.

· Fiscal: NF-e, CT-e, and city service invoices through the Brazilian fiscal libraries, with tax tables for ICMS.

2023 to 2025, Dolado. The company bought a dropshipping platform: sellers listed suppliers’ products on Mercado Livre, Shopee, Amazon and Magalu. Legacy PHP, hundreds of Lambdas, cron jobs. For two years I was its main backend engineer, largely alone, and kept it running.

One product, one order, to show what the platform did. The seller lists the product on every marketplace with one click. A buyer orders on Mercado Livre; the marketplace calls back, and the order lands on a queue.

The platform checks the seller’s tax model and issues the NF-e invoice. Then the picking list, the packing and the shipping label; a carrier collects the parcel, and tracking comes back until it is delivered.

Stock goes down by one and the new balance is synced to every listing on every marketplace. The seller’s sales count goes up and the listing’s health stays green.

What went wrong, over months. Every morning logistics issued invoices in batch; each one lowered stock and fired syncs into MySQL, and the PHP opened a connection per file until the limit blew and logistics froze. Sellers’ tokens expired every two months and their orders stopped, with no alert.

The fixes: one connection per request and separate database credentials per service, RDS with a read replica; traces per seller token in the Cronicle jobs; the queues in Terraform with dead-letter queues; invoices on demand instead of the batch. June 2025: Head of Technology.

· I proposed and architected the redesign: a multi-step workflow of specialised nodes with narrow prompts, structured JSON between them, a hand-picked model per node, token accounting, and real-time streaming. A developer on the team implemented it.

· I structured the MCP server from scratch and implemented a large part of it: browser automation, database questions in plain language, marketplace APIs, reports and presentations. The team kept adding tools.

· What production taught us, and what we fixed as a team: context truncation with summaries of earlier analyses, SQL checked for syntax and column existence with a corrective loop, a math tool over MCP because models fumble arithmetic, key rotation and queued backoff for rate limits.

· I ran weekly dojos that took the team from no AI experience to agents in production in four to five months; one of them was a reflection session on our own problems: scaling automations with five developers, adoption inside the company, and tying short-term work to where the company was going.

· I designed and ran hiring end to end.

The failure, and the redesign

· Before: the market intelligence team answered questions in Excel and Power BI, split files by hand at the row limit, then spent hours building slides.

· Version one, June 2025: one flexible agent, one prompt, all tools at every step: a router, an analysis node, a strategic consultant, a validate node, a memory cleanup. It failed in production: the prompt kept growing, the context window truncated answers, SQL referenced columns that did not exist, failed queries were handled badly.

· Version two, August 2025, my design: a multi-step workflow of specialised nodes. Get the category’s information; validate that historical data exists; generate the report; structure it. Each node has a narrow prompt and only its tools. Structured JSON passes between them, so the context of each step stays small, and each step can validate and recover.

· A model per node, chosen by hand: Claude Sonnet 4 for the planner, GPT-4.1 for the invokers and the structurer. Token accounting per run. Streaming to the chat. Node-level observability in LangSmith.

· A structured intermediate layer, so one analysis fans out into a report, a presentation, text insights, charts, and raw data.

· Production fixes: truncate before processing and keep what matters; validate SQL for syntax and for columns that exist, and feed the error back once; a math tool exposed over MCP; API tiers, key rotation, queued backoff; one leading system message, because the framework and the model disagreed about where it may sit.

· What I learned: start flexible for discovery, add structure for reliability. Adoption is organisational, not technical: the analysts stayed the owners of the process; the agent is their tool, not their replacement. Track usage to discover value: we planned one use and ended with five.

The MCP server

· A Model Context Protocol server the agents call for tools, structured from scratch by me and largely implemented by me.

· Browser automation with Playwright for the marketplace pages. Extraction with Cheerio and Zod schemas.

· Database questions in plain language through a self-hosted text-to-SQL layer; the data lake and the analytics database behind it were built by a data engineer on the team.

· Marketplace APIs for Mercado Livre.

· Reports: PDF and presentations through a self-hosted slide generator made asynchronous with a job queue.

What people used it for

· We planned one use: the default market report, a whole subcategory over a period.

· By tracking usage, four more appeared: deep-dives on a few sections with the terms to ignore; ad-hoc questions (“the top brands by revenue”) without a full report; walking the category tree for other research; extracting prices from specific listings for competitive analysis.

· From the chat: a report, a presentation, charts asked for in plain language, all generated from the same analysis.

· The agent went from a report generator to a research copilot, because it stayed conversational and we watched how it was used.

Three things I would tell another CTO

· Start flexible for discovery, add structure for reliability. The monolithic agent found the real needs; the specialised nodes made them dependable.

· Adoption is organisational, not technical. What won it: the agent ran in parallel with the spreadsheets for weeks, so the analysts compared its results with their own and trusted it on their own terms. The reframing that held: the intelligence team stays the owner of the process and its quality; their role moves from manual execution to insight and the client; the agent is their tool.

· Track usage to discover value. Discovery happens in production, not in planning.

June 2025 to January 2026, Dolado: Head of Technology, a team of five. Analysts answered questions by hand in Excel: 7+ hours of hands-on work for a normal analysis, 24+ for a complex one. We built an agent system for that work; it runs weekly, a diagnostic in about fifteen minutes.

The first version was one flexible agent on LangGraph: a router, an analysis node, a strategic consultant, a validate step and a memory cleanup, with every tool available at every step. It was the right first version, because it showed us what people needed.

In production it failed. The prompt kept growing, the context window truncated answers, the SQL referenced columns that did not exist, and failed queries were handled badly. The slip shows the kind of error it produced.

I architected the redesign: specialised nodes with narrow prompts, JSON between them, a model picked per node, validation at every step; a developer on the team built it. For months the analysts compared their spreadsheets with the agent’s answers, week by week, until only the agent was in use.

We planned one use and ended with five: reports, deep-dives, ad-hoc questions, the category tree, prices. The chat returns reports, slides and charts. I structured the MCP server from scratch and built a large part of it; the team added tools.

The weekly dojo: a chapter of AI Engineering and a topic someone brought. From no AI experience to production in four to five months. Diagnostics in about fifteen minutes instead of a day; the company grew without growing the team, and sellers reached revenue sooner.

· NestJS API, hexagonal: PostgreSQL, TypeORM, Redis and BullMQ workers, a multi-LLM agent orchestrator streaming over SSE, human-in-the-loop pauses, tool-call observability, text-to-SQL memory with full-text search, an MCP server for agent tooling.

· Python LLM and speech service: LiteLLM routing across Anthropic, OpenAI, DeepSeek and Gemini, with Groq and a local Ollama as fallbacks, routed by quality or speed; Kokoro for speech, which replaced Coqui’s XTTS in April 2026, with XTTS back beside it in May for a cloned voice; Whisper to hear the weekly goals a user sets by voice; pre-rendered filler phrases in Portuguese and English to hide the latency, Portuguese being the slower side; Langfuse tracing.

· An Expo and React Native app with Tamagui and tokens-only design discipline; a Next.js site with Chakra UI and Playwright visual-regression baselines as a pixel contract.

· promptfoo evals with LLM-rubric judges gate every prompt change. Every repository blocks a commit that fails architecture, tests, or lint.

· I paused it rather than grow it with engagement tricks or vanity marketing.

The app

· Human-in-the-loop pauses and visible tool calls while an episode is built.

· The player shows the transcript as it is read.

The architecture

· Four repositories: the API, the app, the site, the LLM and speech service. About a thousand commits in about two months.

· API: NestJS, hexagonal (interfaces, domain, infrastructure), PostgreSQL, TypeORM, Redis, BullMQ, SSE, JWT, an MCP server.

· Speech and models: LiteLLM in front of Anthropic, OpenAI, DeepSeek and Gemini, with Groq and a local Ollama as fallbacks; Kokoro and XTTS for speech; Whisper for the voice-set weekly goals; Docker Compose for all of it.

· App: Expo, React Native, Tamagui, Zustand, Reanimated. Site: Next.js 15, React 19, Chakra UI v3, Playwright.

· Quality: promptfoo evals gate every prompt change.

· Every repository blocks a commit that fails the architecture read, the tests, or lint.

March 2026, a product of my own: AI-generated personalised audio for professionals, designed around attention and deep thinking rather than engagement. Founder and sole engineer: four repositories built end to end in about two months, tested with early users, and paused on purpose.

The four repositories are the API, the app, the site, and the LLM and speech service, built with Claude Code under gates that block any commit failing the architecture read, the tests or lint. The phone is the app; the laptop opens the architecture.

LiteLLM routes the models by alias, each with fallbacks: Anthropic, OpenAI, DeepSeek, Gemini, Groq, a local Ollama. For speech I tried several engines and kept two, run locally: Kokoro, and XTTS for a cloned voice. Portuguese was the slow side, so pre-rendered filler phrases cover the wait.

A small group of early users tried it in moderated tests. Everyone used it to consume faster while doing something else, the opposite of what it was built for. I paused it rather than grow it with engagement tactics.

Since then I read and write about attention and the economics of AI in software, and I study Brazil’s law on children’s digital protection and what it asks of a product. The pile by the sofa opens all of it.