ADCA Corp.

multi-services startUp IA first

Comment

Inspiration

Inspiration We are two founders from El Puerto de Santa María, Cádiz, Spain. Neither of us had written a line of code in our lives when this started. One of us comes from sales and strategy, the other from running a company. Between us: zero engineering degrees, zero seed money, zero employees.

What we did have was a market we could see and nobody was serving.

We kept meeting the same business. A jeweller with 1,900 five-star reviews and no website at all. A dentist whose site died in 2019 and still shows a phone number that no longer rings. A builder whose page collapses the moment you open it on a phone — which is where every one of his customers looks. These businesses are excellent at what they do. They are losing customers every week to chains with marketing budgets, and most of them do not know it is happening.

Agencies do not fix this, and it is not laziness — it is arithmetic. A €1,200 website takes days of human work. Prospecting, qualifying, designing, presenting, closing, building, publishing: every step is a person's hours. When each step costs hours, nobody can afford to knock on the door of the corner hairdresser. The market is not underserved because it is poor. It is underserved because the cost floor is human.

So we asked a different question. Not "how do we build websites faster with AI?" — that is an agency with better tools, and it still has a human at every step. The question was: what if finding, qualifying, designing, pricing, selling, building and publishing a website cost cents instead of days? What would a company look like if the staff were not people?

That is ADCA. Not a product with AI inside it. A company where the AI is the workforce, and the two of us are the direction.

What it does ADCA finds local businesses with a broken or missing web presence, proves the problem to them, designs and builds their new site, sells it, buys their domain in their own name, publishes it, charges them and reconciles the money — and reports back to us every morning.

Eleven Gemini-powered agents do the work, each one owning a department:

Lead Agent — Prospecting. Scans a city sector by sector, and for every business it finds it does not just record the name: it tests the site. Loads it on a desktop viewport and on a phone viewport, follows redirects, checks whether the domain resolves at all, reads the copyright year in the footer, measures whether the layout survives a 375-pixel screen. Then it writes down exactly what is broken — dead domain, no site at all, mobile collapse, expired copyright. That record is the sales argument: we are not telling a business owner they might need a website, we are showing them what their own customers see. Today the database holds 26,652 qualified leads across nine countries: Mexico (17,722), Spain (5,427), Colombia (855), the United States (794), Brazil (610), Panama (599), Chile (462), Costa Rica (98) and Andorra (85).

Jordan — CRM and sales. Searches those 26,652 leads semantically, in plain Spanish, through Vertex AI Search — you ask for "restaurantes en Guadalajara sin web y con muchas reseñas" and you get them, not a SQL form. Jordan scores each lead, assigns them to closers, drafts the message, and can hand a lead to an AI voice closer to phone.

Marina and Diego — AI voice closers. They pick up the phone and talk. Real telephony, real conversation, running on Gemini Live for the audio brain with Twilio only carrying the line. The moment the call connects they identify themselves as virtual assistants. They never claim to be human, and they hand over to a person the instant one is asked for.

Web Agent — Production. Designs and builds the actual website: layout, copy, imagery, structured data for search. It does not fill in a template. An art-direction step picks a visual language for the sector, an assembler builds the page, and then a visual QA agent photographs the result with a real browser and scores it against a written rubric. If it scores below the bar, it goes back. The site only ships when the machine that judges it agrees it is good.

Delivery. When a client says yes: buys their domain in the client's name, configures DNS and HTTPS, sets up their info@ mailbox, publishes the site and verifies ten gates against the live domain before declaring it delivered. The domain belongs to the customer from minute one — we are not holding their business hostage.

Finance. Stripe is live. A reconciliation job books settled payments every two minutes, prices are resolved per sector and per country in the customer's own currency, and invoices carry a real tax ID.

Security, SEO/GEO, Legal, Property Dossiers. Four more departments, each one a service we can sell to a customer we already have. The SEO agent optimises for being cited by an AI assistant, not only for blue links, because that is where local search is going.

Axel — CTO. Reads the company's measured state every morning on a timer and reports to us without being asked.

And the interface to all of it is a sentence in Spanish. In a single month our transcripts record 9,028 instructions given in Spanish and 15,166 AI responses. That is not a demo mode. That is how this company is operated.

How we built it Google, end to end. Gemini 3.7 Flash is the brain of all eleven agents, served through Vertex AI with the VM's own service identity — no API key ships anywhere. Gemini Live is the voice. Imagen produces photography for client sites. Veo produces cinematic hero clips. Vertex AI Search runs two indexes: adca-leads for semantic lead search and adca-docs so agents ground their answers in our own documentation instead of remembering. Cloud SQL (PostgreSQL 15) is the single source of truth. Compute Engine runs the panel, the agent runner and the voice bridge as systemd services. Identity-Aware Proxy is the only way into the machine — there is no open SSH port. Secret Manager holds the credentials; nothing lives in the repository.

What is not Google is exactly three things, and we list them because a "built on Google" claim that quietly omits the rest is the kind of half-truth we have spent this whole project engineering against: Cloudflare for domain registration, tunnel and hosting, Stripe for payments, and Twilio to carry phone calls. Anthropic's model is available to the security agent alone, behind a flag that is off by default.

One model, one switch. The model is resolved from a single variable through one client. Moving the entire company from Gemini 3.5 to 3.7 was a configuration change, not a refactor — which is also how we rolled it back in sixty seconds when we found a bug.

Two architectural decisions shaped this more than any framework choice:

1 · Everything is measured; nothing is assumed. The company's state file is not written by a human deciding what is true. It is produced by a script that reads production — git HEAD, systemd unit status, health endpoints, the live database, the presence of environment variables — and writes down what it finds. If a number does not exist, the interface is required to say "no data". It is forbidden from filling the gap. An audit caught our own dashboard quietly reusing an unrelated metric as a placeholder and we tore it out the same day. A company run by AI that is allowed to guess is a company that lies to itself, and it will lie most convincingly to the people who built it.

2 · Guardrails before capability. Agents that can delegate work to each other can also delegate in a circle forever, so the internal bus enforces a depth limit of 2 and a cap of three messages per turn. AI voice closers may call Mexico but not Spain, where our policy says the first contact is human — and that rule lives inside the single function every outbound message and call passes through, not in a document somebody has to remember. Spending ceilings are enforced inside the database UPDATE, not in application code that can be raced. Every model call is logged at the one point every client passes through, so a new call physically cannot be added without being recorded.

Built entirely inside the window. The competition window opened on 19 May 2026. The oldest lead in our database was captured on 26 May. The first commit is 1 June. Since then: 794 commits across 61 active days. Nothing in this company predates the window.

Challenges we ran into This is the part we would most like the judges to read, because it is the honest record of how two non-programmers ended up with a system that holds together.

The server that was dead while everything showed green. Early on, the sales department had been effectively dead for days and nobody knew. The Lead Agent was crashing on import; its locking and deduplication queries had been written in SQLite syntax and were running against PostgreSQL, so 100% of searches failed silently. A forgotten cron job on an old machine kept relaunching the previous version every four hours and the processes never died: 80+ Chromium instances stacked up, system load at 51, three days burning resources. Worst of all, that zombie agent was prospecting correctly — and writing to an isolated local SQLite file. Around a thousand real leads were trapped where nothing could see them. We rewrote the SQL to be portable, rebuilt the environment end to end, cleaned the node, and rescued the unique leads into the real database. The lesson became a standing rule in our operating manual: green logs are not the truth. Recurring processes now only exist as documented systemd units.

The "engine" that was one template. We were selling uniqueness. An audit revealed that our premium website engine was not an engine at all — it was a single restaurant template with about ten strings swapped by the model. The uniqueness we were promising was structurally impossible. We had industrialised the artefact instead of the process. The rebuild replaced it with design tokens per sector, a block library, a model acting as art director, a deterministic assembler and a visual critic with a written rubric.

The critic that caught itself. The new visual QA agent's first real test: it approved a website with a 9/10 whose hero had white text over a bright sky — illegible to any human at a glance. The critic was not wrong, it was blind: it only ever saw full-page thumbnails, where the problem disappeared. The fix was three-layered — a dedicated capture of the first viewport at real scale, explicit "red lines" in the rubric (insufficient contrast caps the score and raises severity), and a non-negotiable rule in the generator's own prompt. On the next run the critic caught exactly that defect, scored it a 4 on contrast, forced the correction, and the final site shipped legible. That loop — look, criticise, correct — is now audited in a _qa.json file next to every site we produce.

One letter broke an entire province. "No se pudo generar ES_A C_FONT_...: invalid lead ID." The root cause was the letter ñ. Our province dictionary stored the key "a coruña" with the ñ, but the normaliser stripped ñ→n before looking it up, so it never matched — and the fallback truncated "A Coruña" to "A C", space included. That space failed the Web Agent's security validation and blocked website generation for the whole province. The investigation turned up 58 more leads from an earlier era with the same defect. We fixed it with Unicode NFKD normalisation (which handles any diacritic — essential for our LatAm expansion), a final regex belt that makes an invalid ID impossible, and a migration of all 110 affected leads in production with an anti-collision guard.

Jordan was talking into the void. He sent WhatsApp messages and got replies, but could not tell which lead a reply came from: the messaging identifier arrived in the webhook in a different shape than the one stored in the database — device suffixes, separator variations. Messages went out, but nothing linked back to the customer's history. Two days and seven commits of layered diagnosis: log the raw webhook JSON to see the actual structure, map alternative identifier fields, add a persistent local cache, sanitise the identifiers. Lesson: in messaging systems, IDs are never clean. That module is now format-agnostic with explicit regression tests.

Workers with no timeout silently halved our throughput. Prospecting runs concurrent browser workers, one per province and sector. Without a timeout, a worker that hit a slow site could hang forever, holding its slot in the pool. Overnight runs had workers stuck for hours: prospecting never failed, it just quietly ran at half speed. Now a worker that exceeds fifteen minutes dies cleanly and returns its slot.

The deploy that never arrived. We shipped visual changes and kept seeing the old version, even on a forced reload. Our assets were served with Cache-Control: immutable — correct for hashed URLs, catastrophic for ours, which were always styles.css. The fix is systemic rather than remembered: the deploy script computes an MD5 of each asset's content and appends it to every reference automatically. If the content changes, the URL changes. immutable without a hash in the URL is a trap, and the rule is now enforced by a script that cannot forget it.

A limit decided outside the transaction is not a limit. We capped AI image spending with a SELECT followed by a check in JavaScript. Ten requests got through a quota of four. The fix was to let the database enforce it atomically, inside the same statement as the write. We now treat any check that is not in the same statement as the write as a check that will eventually be raced.

The same list in six places does not fail — it degrades in silence. Our enum of detectable business pains was copied across six files, and the list of valid currencies across six more. Forgetting one copy broke nothing visible: a lead simply stopped being sellable, or a Brazilian business got quoted in euros. Nothing logged. Nothing alerted.

A price that changes without erroring. A query that forgot to select sector and province did not throw — it quietly returned a different price for the same lead, €768 instead of €1,195. The money is now defined once, in one place, with a guard in CI.

"Sent ✓" to numbers that could not receive it. WhatsApp accepted three non-existent destinations and returned valid message IDs, and our CRM marked all three as delivered. Mexico registers accounts with a different country prefix pattern than the one we were building, so the identifiers were plausible but wrong. A send without confirming the recipient does not fail — it lies. We now ask the provider whether the number exists before sending, and we audited every message ever marked as sent.

Two days before submission, we moved eleven agents to Gemini 3.7 Flash and silently broke them all. Every service came up green. But with a 300-token budget, the model spent 286 tokens thinking and 7 answering, truncating JSON in the middle of a key. No error was raised anywhere: agents simply returned garbage into a system that reported itself healthy. Asking for a zero thinking budget reduced it but never switched it off. The fix was to stop sharing one budget: the caller's limit is now the limit of the answer, and reasoning gets its own separate reserve. We only found it because we measure the actual pipeline instead of trusting a health check.

A compliance decision we made against our own interest. Business data originates from public profiles. When we understood that the restriction in the terms was about storing that data — and that switching to the official API would not change it — we retired the dependency rather than argue with it. It cost us capability. A company run by AI has to be able to make that call.

And the hardest one: honest revenue. Our payment rail works end to end — live Stripe, verified webhook, automatic reconciliation every two minutes, invoices with a real tax ID. The account has exactly two charges in its entire history, and we list both. The one that succeeded, 19.00 MXN on 13 July, was paid between entities belonging to us, to prove the money path. It is a related-party transaction. We report it as exactly that and we exclude it from revenue. ADCA has not yet collected money from an arms-length third-party customer. The temptation to present that charge as traction was real, and giving in to it would have been the fastest way to lose a competition judged on verifiable numbers — and the exact behaviour we forbid our own dashboard from exhibiting.

Accomplishments that we're proud of 26,652 qualified leads across nine countries — every one audited, not scraped and dumped. The database knows what is broken about each business, not just its name. 476,658 verified liveness records. A supervisor probes all eleven agents every sixty seconds and writes down the answer. Not a log line — a verified answer to "is this agent configured, reachable and dispatchable right now?" (evidencia/ holds a reproducible snapshot at 347,571 taken on 7 August.) 3,389 jobs run, of which 1,117 failed — and we publish that number. Because the dates change what it means: every single failure falls between 18 June and 2 July, while the agents were being written and their failures were the feedback loop correcting them. Jobs kept running until submission day. Not one has failed since 2 July. That is not an instability figure. It is the record of how this became stable. 354,298 agent events and 58,813 audit entries, generated by the system doing its job. A measured production cost of US$0.66 per website — 13 model calls, real token counts priced at Google's published rates, retries included. Against a $169 sale that is a 99.6% gross margin on work agencies cannot afford to do at all. Human closers under contract in Argentina and Colombia, working the same CRM as the AI closers, distinguished only by authorship — so we can actually compare who closes better. Today the human does. A live payment rail and a delivery engine that buys a customer's domain in their own name and publishes their site with ten verification gates. A company that two non-programmers operate by writing sentences in Spanish — and which is documented in Spanish on purpose, because translating it would hide the very thing being demonstrated. What we learned The hard part of an AI-native company is not getting the model to do the work. The model does the work. The hard part is building the parts that say no: the country lock, the delegation depth limit, the spend ceiling enforced inside the transaction, the rule against inventing data, the identifier check before a send is marked delivered. Capability was the easy half. Restraint was the engineering.

Measuring beats believing, every time. Every serious bug we hit looked completely fine from the outside. The spend cap that let ten through a quota of four. The duplicated enum that made leads quietly unsellable. The truncated JSON behind eleven green health checks. The dead sales department with clean logs. Each one was found by measuring the real thing in production, and each one would have been invisible in a demo.

Not knowing how to program stopped being the obstacle we assumed it was. What it forced was worse and better: we could not read the code and trust it, so we had to build a company that proves things about itself. The state file, the evidence exports, the liveness supervisor, the QA rubric, the audit trail — all of that exists because neither of us could verify a system by reading it. The constraint produced the discipline.

A constraint on capital shapes the product. No seed round, no runway, no salaries — consumer subscriptions, free credits and our own pockets. Two people without money could only afford a pipeline that costs cents. That is precisely the pipeline that makes the smallest customer viable. The unit economics exist because we were broke.

What's next for ADCA Corp Close the loop we have already built. The machine that finds, qualifies, designs, sells, publishes and charges is running in production today. What it needs now is volume on the closing side — more closers, human and AI, in more countries.

And that is the whole plan, because of one asymmetry: adding a human closer takes weeks of recruiting and a salary. Adding an AI closer takes a line of configuration. We run both against the same CRM, on the same rules, and we let the numbers decide the mix.

Small business services has always been defined by a cost floor. Every business that goes unserved goes unserved for the same reason — an hour of a person's time is worth more than the job pays. We are not arguing that AI helps an agency move faster. We are demonstrating a company where the agency is the AI. If that holds, the addressable market is not the businesses agencies compete over. It is the millions they have never called.

Built With

Share this project:

Updates