Don't bury the horse before you ride it

My app has seven and a half thousand listings and two and a half users. The first number took me a year and change to collect. So did the second.

I'm almost done studying programming in Paris, I live in a dorm, and this is the first article I've ever written. The app is for finding housing. So I'll just tell the story in order.

The hackathon I shouldn't have gone to

In spring 2025 a buddy dragged me to a Starknet hackathon in Paris. The ideas were supposed to be AI-flavored but crypto-based, and you can't come up with a good one in two days. So we took an old idea of mine, a map where you could find local groups and services, and made it crypto-native: services right on the map, payment straight in crypto. We shipped the prototype right from the hackathon floor. It had no chance, and we knew it. We did it for fun.

But I couldn't shake the idea. I had plenty of free time: no job, and the market was rough. Or that's how it felt at the time; these days I remember that market almost fondly. And I couldn't make myself prep for interviews: drilling algorithm puzzles and memorizing language trivia, all those tasks in a vacuum, had me climbing the walls. I sincerely believe you can land a job the normal way. Ha.

So I thought: why not try my own thing instead? Anyone thinking clearly can see how dumb that plan is. Interviews are a marked trail: level up, follow the markers, repeat. Building your own product with zero days of product experience is a trail with no markers at all. Picking the second to avoid the first is a questionable trade. But it wasn't my first time. Before tech I opened a coffee shop and a tea store.

On May 13, 2025, I gave the project a clean repository (the hackathon prototype stayed in the old one) and made the first commit: initial react 18 setup and webwallet integration. Webwallet, because the project was, of course, Web3.

I'll come back to that date.

The app that had everything

The project was called Pinks, from pin and inks: ink blots on a map. The idea was simple: the map shows people, services and local groups in different languages. Maps of nearby services already existed, strictly speaking. The new part was the mechanic, a ping instead of a catalog of listings, plus the crypto context around it. Search ran on tags, and the tag system grew genuinely elaborate: every category carried its own tags for very fine distinctions, which made search and matching more precise than plain text embeddings could manage.

The map was the center of everything, and I couldn't let go of it until the very end. I was in love with hyper-locality: not "in this city" but "in this village, two houses down."

What I couldn't do back then was everything else. I didn't know what a user story was. I had barely written any frontend, and the whole thing was going to be frontend. I invented the interface myself, my own way, on purpose: I wanted something custom, it was a creative experiment. In today's terms, the concept was generative UI, only hand-coded, no models involved: the data people put in was free-form, and the interface was supposed to reshape itself around what they chose. I understood only later that this is too complex to build without models and a lot of experience. I was reinventing the wheel deliberately, trusting that a sense of style could stand in for conventions. I saw nothing like my idea anywhere, and that looked like an advantage.

Now I know what that's actually called. If you invent a UX pattern that doesn't exist, you have to teach it to the user through the interface, and you can't teach something that has never existed. There's no reference point for you, and none for the user. The conventions I was dodging in the name of creativity turned out to be other people's mistakes, already paid for, not a cage. Creativity only works on top of a trained eye, and I hadn't even started training mine.

The funny part is that I knew the right way. I read the product-launch channels and saw a method you could literally follow step by step: study demand, do the research, then build. I ignored it. First for fun, then out of inertia.

There's a fork in the road here that I didn't see at the time. Some people ship raw, janky stuff. They don't care what anyone thinks, and in return they get feedback instantly and their hypotheses die fast and cheap. I went the other way: I polished, so nobody would open my app and think "what a piece of crap." Those people learn the truth in a week. I learned it in ten months. It was the same truth, only much more expensive.

Meanwhile I was trying to have it both ways, structuring everything to fit both Web3 and Web2. It sounds far-sighted and works terribly. Even ordinary images are heavy in Web3, and above all, these are two different users: crypto people will happily figure out something weird, and a normal person just closes the tab.

I wrote all of this pair-programming with GitHub Copilot, back in the small-model days. From day one I was curious whether you could build a product by leaning on AI completely. The 2025 answer: no. I did almost everything by hand (styles, logic, decisions), with no design system and no UI kit, because "it's just a prototype."

I didn't start alone, by the way. After the hackathon the project was a shared thing too, with the same buddy. Only the plans stayed shared: he endlessly promised he was about to do something, and did almost nothing. At some point I had to remove him from the project. "The hardest part of any venture is building a strong team" is a thought as old as time, but I've been wrong about people on my own ventures so many times that it stopped being an abstraction long ago. When people work for money, everything is simple: the motivation is clear. The genuinely hard case is no money and a flat hierarchy. Misjudge one person, and there goes a month.

"I can feel it"

In early August 2025, less than three months after the first commit, the same buddy and I went to show all this to a well-known Paris accelerator. I didn't come empty-handed: I knew I had to show how the app would make money. The paying side was supposed to be small entrepreneurs whose services live on the map. And the market wasn't a guess: in Russia, marketplaces for services from private individuals had been popular for years, and in France I had found almost no analogs. In my head that made the project half B2B, and I kept stressing the point. In the investor's head it didn't. I'm reconstructing the dialogue from memory, so not verbatim, but it went roughly like this:

"What's your market?"

"It's a social map. People nearby, services for nomads..."

"That's B2C. B2C is hard by default, everyone wants B2B. What services, for example?"

"Say you arrive in a country, your car breaks down, and you don't speak the local language. Happened to me. I was looking for a plumber..."

"Nobody needs this."

"Why?"

"I can feel it. I have a lot of experience."

He also asked about retention. I couldn't produce a coherent answer: to me it was obvious, and the obvious is the hardest thing to explain. Now I think no explanation would have helped. What he needed wasn't big numbers so much as proof that the money he put in could be pulled back out fast. People like that don't play the long game: they want the quickest possible return on the smallest possible stake. It looks more like betting than investing. What I had was a small market and a long game.

I walked out crushed. I had never talked to this type of person before, the type who makes you defend your product's right to exist. Something else stung separately: the buddy kept dutifully backing me up on the call and, as I now understand, didn't mean a word of it. He didn't believe in the idea or in me. That hurt more than the takedown itself.

Now, about that date. On May 13, 2025, the day of my first commit, Airbnb's Summer Release launched Services: services from individual people, right in the app, in 260 cities at once. So by the time of that conversation, the biggest company in the market had been running the exact thing that "nobody needs" in production for almost three months. Neither of us in that room knew it. He didn't, because he could feel it. I didn't, because I never looked.

I stumbled onto the news that fall and went around telling everyone: "See, I was right!" The real discovery came later: "right" and "broke" are perfectly compatible states. And the investor was right too, in his own way. Just not about the market. About me. People like him want a finished thing they can flip for a check under a hundred grand, and they seem to hunt for small bets on B2B SaaS. The one from the memes. The one every other dev is building right now. I had brought them free B2C and a dream of everything at once.

The most telling part of this scene is something I only spotted now, while reconstructing the timeline for this article. The takedown happened in the project's third month. The first public announcement came seven months after the takedown. For seven months after "nobody needs this" I kept building: silently, showing nobody, testing nothing.

From the inside the logic felt ironclad: so much is done already, stopping now would be stupid, let me just finish, and then... And the more I had put in, the more convincing "finish, and then..." sounded. Now I know what the textbooks call that logic: escalation of commitment, sunk cost feeding itself. Back then it was called "perseverance."

Cutting

In October 2025 I started a job, and project time shrank to evenings and weekends. Then came the longest and most useless period: inertia.

That fall the project stalled twice. I never decided to pause and never decided to continue; it simply fell out of the schedule. I came back on December 7 with a commit called, verbatim, "dont know". Apparently I didn't know myself why I was back: too much had gone into it to call it the end.

The hardest skill of the year turned out to be not programming but cutting. Throwing away your own work physically hurts, and you don't suspect that cutting will make everything lighter and faster until you actually cut.

The hardest skill of the year turned out to be not programming but cutting. Throwing away your own work physically hurts, and on top of that I seem to run family firmware that says "more is always better." You don't suspect that cutting will make everything lighter and faster until you actually cut.

And there was plenty to cut. My app contained sublets, services, trips, cross-border parcel delivery, chats, and people. Each vertical, it turned out, has its own quirks it can't work without: rentals need tags and date ranges; trips and parcels need two coordinates instead of one, sometimes several. A "universal tool" in practice means N products at the price of N. I shut down parcels when I found an app that had already done them well (and was honestly upset the niche was taken). Trips were the hardest to let go: the usefulness is obvious to the naked eye. I cut them anyway.

In hindsight there was even discipline in this. Traders have a boring word for it: stop-loss, an exit threshold you set before the trade, not at the moment of pain. I had a stop-loss on every feature. On the project itself: none. A competitor does it better? Cut. The vertical's quirks are too much for me? Cut. But the question "should I cut the project itself" never came up once all year. Not "I decided to keep going." The question simply never came up.

Two things survived: sublets and chats. Sublets survived because I had seen the demand with my own eyes, and not just in posts. In our dorm group, one of the guys had already built a bot for posting apartments, and it worked for him. A tiny market, but a live one. In my head that settled the validation question: hypothesis confirmed, works for him, will work for me. That's partly why I kept building in silence so calmly. There seemed to be nothing left to test.

What I had missed in that story I learned much later, when I asked him directly. First, he didn't start with the bot. He started with marketing: he primed our chat and a neighboring one, and only then released. Second, he soon dropped the bot. He did the math, decided maintenance cost more than it brought back, and calmly walked away. From his story I took the proof of demand and left everything else on the table: the distribution, the cost of maintenance, and the third, most expensive part, the ability to walk away once you've done the math. Exactly the set of things I would go on to slam into myself.

I resisted cutting even in the small stuff. An acquaintance told me back then: throw out all the contact methods, keep only Telegram, and run everything through it. But I wanted an author to be reachable "whichever way is convenient": Telegram, WhatsApp, Discord, Instagram. I couldn't bring myself to cut that. Surely I could build all of it, and it would be great. I'll come back to that advice too.

Around this time a couple of guys turned up who wanted to work on the project with me. They had their own vision: rename it, rebuild everything from scratch, lift ready-made solutions from competitors. Tellingly, I was ready to agree. Then several friends asked me the same question, each on their own: "What do you need them for? You haven't tried to sell your idea to anyone even once, not even over Telegram." We quietly went our separate ways; they found more promising projects. I think they had spotted what I refused to see: enthusiasm doesn't solve the cold start of an app that sells listings you don't have.

A friend with a room

I have a study of how it doesn't get solved, sample size of one.

A friend of mine was renting out a room. The perfect first user: a live need, a warm contact, wants to help. To get him to post his listing through my app, I had to beg and remind him several times. The form was on the complicated side, with rough edges, and even back then I had a criterion: if a user stalls for more than a couple of seconds, that's a fail. His verdict: "All good, all clear. Just the map part is a bit confusing." Then he dropped the pin on a different street in a different district. The two streets shared a name, and the tail of the address, the part that tells the districts apart, had simply been cut off in the input field.

A person who wanted to help me couldn't get through my flow correctly after three reminders. In his usual group he would have typed "hi, renting out a room" in thirty seconds and gotten more reach than my app could offer. That's when I understood that calling my listing-creation UX pointless would be generous. It loses to a paragraph of free text on every count: plain text is just nicer to write, and models are already very good at turning free text into structure, and cheap enough that I could afford them.

One shot

Posting a link to two Telegram groups is a one-minute step. It took me ten months. When you build alone, you live in your own world: you imagine people using your thing, and you're in no hurry to test that picture against reality. The picture might not survive the collision.

The obvious explanation for those ten months is perfectionism. I no longer believe it, and the evidence is fresh: I'm publishing this article without showing it to a single reader first, and I'm fine with that. A perfectionist couldn't do that. With the app it was something else: without product experience you simply don't know when a thing is ready. You can't tell "bad but usable" from "not usable at all." From the inside both look the same: something's off, needs more work. So "finish, and then..." had no stopping condition. "Ready" was undefined. Today I think my app was the second case the whole time. Not bad. Unusable. The friend with the pin was the measurement.

In mid-March 2026 I reread the message one more time, braced myself for criticism, and hit send.

The first group was ours, the dorm one: plenty of people there know me personally, and rooms get passed around all the time. The second was somebody else's, five hundred people or so; I had cleared the post with the admins in advance.

My own group barely reacted: I talked it over with the guys who also build things on the side, and that was it. The other group got me fifty likes. Two people asked for the link so they could share it onward. Then I opened the metrics: people came in, saw a map with a few demo listings, and left. For good.

So I wrote to ten people directly. Carefully, no selling: I'm in Paris, I'm building a free app for finding housing, access by private link. All ten read it. Zero replied. Nobody even told me to get lost.

I was angry for two days. A free app. I wanted to help people. They left likes and went silent in the DMs. I had braced for criticism. Reality had something scarier in store: criticism is at least attention. What I got was silence.

I know how this looks from the outside: DMing people is cringe, and ten people is not research. Agreed. And the contacts weren't exactly warm either, more like not entirely cold. But when a free, useful thing gets zero replies out of ten, the problem is not sample size. It's not statistics. It's a diagnosis.

One more confession, about the channel. Group posts and DMs were my entire marketing. Not on principle: when I started building, I assumed I'd have money for ads. Then I didn't. And a free channel has brutal mechanics. You can't post to the same group twice, so there's no A/B testing; there was exactly one version of the copy. The message I kept rereading before sending wasn't "variant A." It was the only shot.

An evening with a beer

The read receipts hit harder than the empty map. I had rewritten the frontend and the UX more times than I could count, all so that a person opening the map would finally get what this was. I had already cut things: parcels, trips, extra contact methods. It felt like I had paid the entry fee, in months, in rewrites, in everything cut away, and that this much effort had earned me at least a reply. The silence explained that it hadn't. The response is never proportional to what you put in.

That evening, over a beer, the anger finally condensed into a thought: to hell with it. People already post housing in Telegram groups, every day, by the thousands. They just can't search it there. And the groups are open, after all. Why not just parse everything that's already in them?

One decision, and a whole list of problems disappeared: creation forms, host onboarding, moderation, the cold start. The supply already exists. My job is not to talk people into posting. It's to make readable what they post anyway.

Git remembers that week better than I do: the announcement on March 15, the first commits of the chat parser on the 22nd. One week passed between the decision I had spent ten months walking toward and working code. The pivot itself was fast. Admitting it was needed was the slow part.

A one-evening job

It looked simple: shove the text into an LLM, ask for JSON, done in an evening. That delusion cost me several months, and it still hasn't fully worn off.

Live posts are arbitrary language, several languages at once, prices that say "DM me," the same apartment in five chats under five different write-ups. Dates like "June through August or longer": is that short-term or long-term? No dates at all, or only one: is it by the night or for the whole stay? A sublet, or a regular lease with papers? An address that is only the nearest metro station or a landmark? A merely good model is not enough. I had to build a system: my own prompt with dozens of policy decisions (what counts as a fact, what counts as the model guessing), a benchmark on a hand-reviewed golden set, routing between models by cost and quality, a classic-ML filter in front of the LLM so I don't burn money on chatter from noisy chats, deduplication, and my own admin panel with a dashboard.

That filter deserves a line of its own: it looks like a footnote and it is what holds the economics together. Chats carry far more chatter than listings, and paying a language model to read it is the fastest way to burn a budget. So in front of the LLM I put a logistic regression over text embeddings, trained on some eight thousand messages from my own chats: next to a model call it costs approximately nothing, and at the threshold I chose it misses 0.7% of the real listings. I switch it on chat by chat, carefully: first it scores in the shadows without dropping anything, and only once the numbers for that chat line up does it get to cut. Classic ML didn't die. It just moved to the front door.

There is exactly one way to know where you stand: a golden set. I collected 150 listings, deliberately skewed toward hard cases, and worked through every one by hand against my own rubric. Rows labeled by my first prompt had an error in at least one field 78% of the time; rows from the current prompt, 24%. That's a yardstick for progress, not the system's accuracy: the sample is nasty on purpose. I still haven't gotten to follow-up messages ("still available?", "price changed").

Today the parser is half the project, if not more. It will get its own technical write-ups: why that regression was a far less obvious move than it sounds, and how it quietly broke the moment the chats moved to another country; and how I benchmarked ten models hunting for the cheapest one that doesn't lie. There are a lot of numbers in that story, and a lot of comedy.

A layer over Telegram

The final cut was the most radical: I switched off the entire creation UX. Switched off, not deleted: the forms, the composer, even my own messenger still sit in the repository behind a redirect and can be turned back on at any moment. I wasn't cutting code. I was cutting scope. The project stopped being a platform you upload things to and became a layer over Telegram: a structured feed and map of posts from local groups, with price, dates and area, where every post leads back to its author in Telegram. Posts, not listings. Not a real-estate catalog: posts by real people, but now you can find the one you need. Filter by dates, by price, room or whole apartment, instead of reading a month of chat history. And the map that had stood empty for almost a year finally filled up, with thousands of posts I didn't have to beg anyone for.

The whole service is, at bottom, search. I used to spend evenings scrolling those chats myself, fishing dates and prices out of walls of text. Now that's a filter. The deal stays where it always was: in a conversation between two people. I'm not part of it and I take no commission. And I'll remove any chat from the sources the moment anyone asks.

That old advice, "keep only Telegram and run everything through it," came true word for word: the whole project now is that advice. My acquaintance was right a year ago. It's just that, in the end, I wasn't the one who finished the cutting.

The project changed its name along the way. Pinks with its ink blots made no sense anymore; the focus is housing now. The new name is Koloq: "kolo" means "around" in Slavic languages, there's an echo of kolobok, the rolling bun from Slavic fairy tales (nomads roll around like that too), and of the French colocation. I dashed off the logo in one go, and people don't get it. Right now I don't care. I didn't want to spend time on it, and that is progress too, by the way: the old me would have burned a week on it.

Around the same time came a quiet milestone, one I count among the biggest. My neighbor is a UX designer. Starting that fall, he would look at my screens and fail to tell what was happening on them. He couldn't help me, because I couldn't explain the task. After all the cuts he looked again, started to understand, and helped me redo the design. If you can't explain what you're building, you can't sell it. Not to a user, not to a designer, not to an investor.

The pretty design came with a trap of its own. When I showed the site around, several people had the same reaction: "Oh, is this Airbnb?" At first it sounds like a compliment. Then it lands: it's a verdict. I'm not Airbnb and can't be. They're a glossy marketplace with millions of cards; I have posts by real people from Telegram chats. When a layer over chats looks like a corporation, it promises what it can't deliver and hides what it actually has.

That's how I learned that a product has one more kind of positioning: visual. Style isn't set by the designer's taste but by who your audience is and what kind of thing you are. A social platform needs a plainer look: flatter, scruffy in places, like a feed run by people rather than a storefront run by a company. I redid it. It still looks rough in places, and a lot of the old gloss remains, but now the roughness reads editorial instead of polished SaaS template. And I'm holding myself back from polishing further: first the thing has to become something somebody needs.

Can agents do it all

The timeline of tools in this project is itself an answer to the question I've been curious about since day one: can you build a product by relying on AI completely?

2025, Copilot on small models: nearly everything by hand. Then strong models, in small doses. Then it became possible to prompt your way to a genuinely pretty design that looks like a real app, no designer involved; the right details started landing in hours instead of weeks. Now agents write code faster than I can review it, and verification has become my main job.

But don't go thinking the agents have covered everything. Styles, layout, screens: those were covered long ago; CSS was never the problem. The problem is structure. The code's architecture (reducers, state machines, functional style) came from me, because I had done the reading and had the long conversations with models about how to do it right. In a whole year, not one agent proposed a state machine on its own. Until you ask, it doesn't exist.

Even smart models keep extending whatever code is already there, out of inertia. Truly strong solutions come only from the latest generations, and only when steered. The hardest part is getting an agent to treat the cause instead of the symptom. It will gladly fix the glitchy button; it will almost never guess on its own that the button glitches because of a broken data model two layers down. So no, you still can't build a product without understanding the code. You'll have to understand it.

Meanwhile, if you believe the feeds, everyone else's agents figured it all out long ago: code writes itself all day, whole projects at a time. Whether those projects work is not a question people ask. My project is also largely written by agents. The difference isn't the agents; it's who cut the scope, who verified the output, who made the decisions. Code became almost free and time didn't: building the unnecessary is cheaper than ever, while finishing it and verifying it still falls to a human.

There's a perfectly literal illustration in the books. The biggest expense line of the project's year is not the servers (those cost pennies) and not the LLM pipeline (which I actually optimized). It's the subscriptions for the agents that write the code. In round numbers: about $5 a month for the servers, about $10 for the LLM pipeline, about $100 for the agents. My own time, if I ever counted it, would outweigh all three together. AI made code cheap and became the main cost. Hence the most counterintuitive conclusion of my year: agents made the skill of cutting more important, not less. Breaking the "build simple things" rule became cheap. The penalty stayed the same.

Here's the list of decisions that decided the project's fate: what to cut, whom to show it to and when, admitting the creation UX was dead, parsing Telegram instead of persuading people, changing the name. Not one of them was made by an agent. Agents removed the cost of writing code and thereby raised the price of everything else: taste, focus, conversations with real people. A year ago I thought AI would make the product for me. Now I think AI made me: someone who can see a product through.

The generalist's curse

All my life I've been switching stacks and languages: Python, Go, Rust, TypeScript, crypto, backend, now frontend and LLM pipelines. I considered it my curse. The market wants people with ten years in one stack, and I have two or three years in five of them. I tried to go deep in each one, but pitching myself as one specific kind of specialist was always hard.

This year changed my mind, partly thanks to a thought from an interview with the person who once built YouTube's mobile app. Models evolve faster than anyone's stack can go stale. Before the parser, my model experience was around the edges: embeddings, RAG, experiments. Half a year later I had a production pipeline with evals, model routing and cost control. Not because I'm special, but because the fundamentals transfer, and the rest can now be picked up at a speed that didn't exist three years ago.

Articles like this one are probably the worst way to sell yourself: experience that can be checked sells worse than experience told beautifully. But of all the ways, this is the only one that doesn't pinch.

The low point is now

The pretty version of this article would end with "and then it all worked out." The honest version ends differently.

The low point of this story is not the accelerator takedown and not the ten read receipts. The low point is right now. I have a year behind me of holding down a job and building the project in parallel, practically without weekends and barely going outside. It brought no money; the job outlook is uncertain; Koloq has two and a half users; the launch is only beginning.

One of the two and a half is an acquaintance who sent me a chat from Georgia and asked me to parse it. While I was parsing it, it turned out the data model had to grow: short sublets, long sublets and regular rentals are different deal types with different UX, and pulling time spans out of live text is its own kind of pain. The very first real user cost me weeks of pipeline work.

Do I have an entrepreneurial streak? It seems so. Am I ready for what it slams into (money, sales, investors)? Honestly: I don't know.

The decision from that beer evening closed the chicken-and-egg problem. But closed doesn't mean "worked." Closed means the project finally has the one thing it was dead without under any design: content. Whether it works out is a question for the next few months. And that question is no longer about code.

The one thing I did by the book on the first try all year happened after all the events in this story. I wrote down the thing the project had lived without for ten months: an exit rule, what the product books call kill criteria. In advance, with numbers, before it hurts.

It goes like this. Once the feed is stable and I've run a proper announcement across my three live cities, the project gets twelve weeks. If by then fewer than ten people have signed in (not counting me and my friends), and not a single "add my city" has come from a stranger, I stop spending my evenings on the project. The parser stays on cron, the site stays up: the last cut is the same kind as all the previous ones. A switch, not an amputation.

The numbers may turn out naive. Doesn't matter. The point of a stop-loss is not that the numbers are right but that they were set before, not after. A rule without a test is meaningless, but a test without a rule is endless. I spent a whole year proving that on myself.

The saying advises: the horse is dead, dismount. The saying has been ridden to death. My horse, though, was never ridden at all: it stood in the stable for ten months. Burying it was as foolish as believing it could gallop. Don't bury the horse before you ride it. The twelve weeks are the ride.

The checklist of first-product mistakes has been published a thousand times. I knew it in advance and still hit every item:

• didn't study demand;
• built for everyone at once;
• fell in love with a feature;
• went ten months without announcing;
• brought people a solution instead of a question about their problem;
• talked people into filling out forms while the supply sat in open chats.

Now it's not somebody else's checklist. It's a list of things I will never do again.

Here's what I have instead of a happy ending. A product seen through to the end, not a prototype but a working system: 12 Telegram chats in 9 countries; ~250 messages a day enter the pipeline, ~90 reach the LLM, ~70 become listings. Three cities where the feed is genuinely alive (Tbilisi, Berlin, Paris) and a dozen more where it's barely breathing. 7,500 listings in total.

And one number I only spotted in hindsight: 86% of the project's commits happened after that December "dont know". Nearly the whole system was built in the last eight months; the first seven were tuition: UX, frontend, and a concept that had to be thrown out. "Seen through to the end" is itself a result most ideas never reach.

All of it lives at koloq.co. If you're looking for a room or a sublet in Tbilisi, Berlin or Paris, there's a feed and a map of posts from local Telegram groups: price, dates, area, and from every card you message the author directly in Telegram. The server is sized for the two and a half users. I never once optimized for load this year, because there was no load. So if the page doesn't open, this article has more readers than the product has users. Come back a little later.

And if people in your city hunt for housing through Telegram chats, send me two or three links. That's literally all it takes for a city to appear: I join the chats, run their history through the pipeline, and message you when the feed is alive. If a chat's format suits the parser, it takes a couple of hours; exotic ones need extra work, but I'll write about that too.

One last irony, which I only spotted while finishing this text. It all started with me desperately not wanting to prep for interviews. It ended with an article that, let's face it, is my interview prep.

I'm looking for work right now: applied AI / GenAI, model pipelines, evals, and the product around them. If you want an engineer who went from "didn't know what a user story was" to a production LLM pipeline in one year, details and contacts are at koloq.co/about. Or write to me directly: @tonypony on Telegram, or [e-mail].