Реклама ВКонтакте умерла: что происходит с Vk ADS в 2026 году

С апреля 2026 года реклама нутры во ВК стала убыточной из-за ужесточения модерации и изменений в её алгоритме. Креативы либо не проходят проверку по надуманным причинам, либо модерируются частично — одобрены только на площадках вне таргета, что исключает показы. Домены чаще банят, ссылки приходится менять, пиксели пересчитываются. В итоге цена лида выросла настолько, что вместо 10-20% ROI арбитражники получают -20% или -30% даже на объёме. На см…

S2S Postback пропускает до 30% конверсий. Остальное улетает в атрибуцию

AppsFlyer пишет прямо: без S2S Postback до 30% конверсий могут теряться или приписываться неверному источнику.
Параллельно «чистый» BIN в 2023–2024 сократил срок жизни с нескольких месяцев до 2–3 недель, а выпуск карты с «трастовым» BIN в Q1 2024 подорожал на 15–20%.

Для тех, кто строит свои трекинг-цепочки и платёжную инфраструктуру, это не косметика. Если postback не закрыт на сервере, вы платите за шум в данных. Если BIN-слой не обновляется быстро, экономика карты и воронки едет быстрее, чем успеваете пересчитать EPC.

Минимум, который стоит проверить завтра: S2S в трекере, дедупликацию конверсий, TTL по BIN и реальную стоимость выпуска карты в текущем окне. Иначе атрибуция считается, а прибыль — уже нет.

—
Тему oss прокачать — @oss_saas_desk ведёт системную рубрику

Self-hosted LLM окупается не от “дешёвых токенов”, а от стабильной нагрузки и контроля SLA

Если считать честно, self-hosted — это не альтернатива OpenAI “в лоб”, а отдельная экономика. В расходы входят не только GPU, но и простои, DevOps, квантизация, резервирование, мониторинг и время на деградацию качества после компрессии.

Считаем по формуле:
• CAPEX/GPU amortization
• электричество и охлаждение
• оркестрация: vLLM / TGI / llama.cpp
• стоимость поддержки пайплайна
• цена ошибок: повторные запросы, bad outputs, ручная модерация

Самая частая ошибка — сравнивать только $ / 1M tokens. На малом объёме API почти всегда выигрывает: нет простоя, нет недозагрузки, нет инженерного налога. Self-hosted начинает сходиться, когда:
— поток запросов достаточно ровный;
— модель используется много часов в сутки;
— можно держать высокую утилизацию GPU;
— качество на open-source модели уже приемлемо без постоянного fallback в коммерческий API.

Отдельно смотрите на контекст. 128k в маркетинге и 128k в проде — разные вещи: длинный контекст резко повышает latency и съедает throughput, особенно на скромной VRAM. Иногда выгоднее сделать RAG и держать короткое окно, чем покупать больше памяти ради “запаса”.

Если хотите считать правильно, ведите три метрики: средняя загрузка GPU, стоимость 1M токенов на реальной смеси запросов и долю запросов, которые всё равно уходят в fallback. Именно эта тройка показывает, где self-hosted уже экономит, а где пока только красиво выглядит.

На Githab выложили Opengram - самостоятельный сервер Telegram

Opengram — open-source аналог Telegram, который позволяет развернуть мессенджер на собственном сервере для внутренних нужд компании. Платформа поддерживает основной функционал официального клиента: группы, каналы, боты, видеозвонки и Bot API. Для работы можно использовать стандартные приложения Telegram (десктоп и мобила), изменив параметры подключения. Архитектура базируется на микросервисах в Docker Compose с инфраструктурой MongoDB, Redis, Ra…

Self-hosted LLM выгоден не тогда, когда «дёшево», а когда у вас есть стабильный объём

Если считать экономику честно, сравнивать надо не «цена GPU vs цена API», а стоимость 1M токенов при вашем реальном паттерне нагрузки: длина промпта, длина ответа, процент повторных запросов, требования к контексту и SLA.

— При малом и рваном трафике API почти всегда выигрывает: нет простоя, нет DevOps-накладных, не нужен резерв под пики.
— При стабильной загрузке self-hosted начинает брать своё за счёт утилизации GPU. Ключевой параметр — не peak throughput, а average utilization.
— Длинный контекст резко меняет экономику: 32k и 128k токенов бьют по памяти и снижают throughput сильнее, чем кажется на бумаге.
— Квантизация уменьшает стоимость инференса, но добавляет риск деградации качества на сложных инструкциях и tool-use.

Минимальная формула для прикидки:

cost_per_1M = (GPU_hour_cost + infra + ops) / throughput_per_hour

Для продакшна считайте ещё три вещи:
— очередь: если p95 latency растёт, вы переплачиваете простоями пользователя;
— fallback: часть запросов всё равно уйдёт в внешний API;
— резерв: одна перегруженная GPU дешевле на слайде, но дороже в инциденте.

Self-hosted окупается не «на модели», а на профиле нагрузки. Если у вас предсказуемый поток, повторяемые задачи и свой стек вокруг inference — считайте окупаемость. Если нагрузка хаотичная, API часто рациональнее.

Tap trading - новая игра на основе курса Solana

Duelbits запустила Tap Trading — игру на предсказание движения курса Solana за 10 секунд на основе реального биржевого курса. По сути это переупакованные бинарные опционы с двумя кнопками (вверх/вниз) и графиком цены, без выбора времени и валютной пары. Разработчик позиционирует продукт как прорыв в криптоиграх, но реально это копия давно известной схемы. Обновление на рынке, где бинарные опционы никто не забывал и остаются привлекательными для …

🧠 ещё больше CPA-инсайтов → https://t.me/+iRC9bTowfLw4ZDc8

Qwen в проде: 5 ошибок, из-за которых модель кажется хуже, чем она есть

Qwen часто ругают за “плавающее качество”, но в 80% случаев проблема не в весах, а в настройке пайплайна. Если у вас задача на русском, англоязычных tool-calls и длинном контексте, модель может быть очень сильной — но только при правильном режиме инференса.

— Слишком маленький контекстный буфер. Если модель учат работать на 32k, а в проде режут до 8k, она теряет связность и начинает “додумывать”.
— Неправильная квантизация. Для генерации кода и строгих ответов int4 иногда даёт заметную деградацию на сложных шагах; для чата чаще хватает int8 или аккуратного gguf-Q5/Q6.
— Низкий max_new_tokens. Qwen часто раскрывается не в первом абзаце, а после нескольких связных ходов; слишком короткий лимит убивает качество ответа.
— Неверный формат промпта. Если смешать system/user/tool без дисциплины, модель хуже следует инструкциям и чаще уходит в болтовню.
— Переоценка одной метрики. Хороший throughput не спасает, если падает точность в extraction, JSON и многошаговых рассуждениях.

Для отбора делайте не общий “чатовый” тест, а 3 коротких набора: structured output, long-context recall и tool-use. Если модель проходит их стабильно, значит проблема была не в Qwen, а в вашем inference stack.

5 ошибок при выборе Llama для продакшена: от «дёшево» до дорогого простоя

Llama в проде оценивают не по хайпу, а по четырём осям: качество, скорость, цена инференса и лицензия. Если у вас свой API, сначала фиксируйте сценарий: чат, классификация, суммаризация, tool-calling. Для каждого сценария нужен свой размер модели и свой потолок контекста, иначе вы переплачиваете за VRAM и получаете просадку latency.

Первая ошибка — брать слишком большую модель «на вырост». На одном GPU рост размера почти всегда бьёт по throughput сильнее, чем даёт прирост качества. Вторая — игнорировать квантизацию: fp16 для прототипа ок, но в проде 8-bit или 4-bit часто дают кратный выигрыш по памяти без критичной потери качества.

Третья — не мерить реальный prompt length. Контекст 128k на бумаге не равен 128k в рабочем режиме: после роста prompt’а latency и расход KV-cache быстро съедают токены/сек. Четвёртая — не сравнивать движки. vLLM обычно берут за throughput и батчинг, TGI — за стабильный serving, llama.cpp — когда нужен CPU/edge и gguf. Один и тот же Llama на разных стекках даёт очень разный cost per 1M tokens.

Пятая — забывать про лицензию и источник весов. Для коммерческого API это не формальность: сначала проверка условий, потом интеграция и только потом нагрузочное тестирование.

Правильный порядок такой: сценарий → размер → квантизация → фреймворк → замер throughput на своём железе.

Санкции на крипте: что делать с меченой криптовалютой

В конце мая 2026 года Великобритания санкционировала криптовалютные сервисы за работу с Россией, включая биржи Huobi Global и Exmo. Пользователи, получившие крипту от этих платформ, поймали метку «опасные источники» при AML-проверке, что затрудняет обмен и может привести к блокировке средств. При возникновении проблем нужно немедленно писать в поддержку с доказательствами легальности транзакций: скриншотами P2P-сделок, квитанциями от партнёрок …

🧠 Ещё больше инсайтов → в канале AFF.top

🔗 Рекомендуем @oss_saas_desk — соседи по теме (oss).

В России введут комиссию за обмен USDT

Российский законопроект впервые чтения вводит регулирование криптовалют через пять категорий организаций и требует налогообложения прибыли криптообменников. Закон затронет популярные активы типа USDT и BNB, контролируемые недружественными странами. Основная цель — обязать обменники делиться доходами с бюджетом через комиссии и экономические стимулы, что в итоге увеличит затраты для рядовых пользователей и может стимулировать переход на альтернат…

➡️ Читайте на сайте: https://aff.top/blog/v-rossii-vvedut-komissiiu-za-obmen-usdt

🧠 Ещё больше инсайтов → в канале AFF.top

vLLM и TGI ломаются не на модели, а на плохом планировании памяти и контекста

Если у вас одинаковая Llama/Qwen/DeepSeek, разница между vLLM и TGI часто упирается не в «качество ответа», а в то, как сервер держит KV-cache, батчинг и длинный контекст. Ошибка №1 — запускать 8k-32k контекст на машине, где память рассчитана только на короткие запросы: сначала всё быстро, потом начинается фрагментация и резкий провал throughput.

vLLM обычно берут, когда нужен высокий throughput на mixed workload: много коротких запросов, параллельные сессии, динамический batching, непрерывная подача токенов. TGI чаще удобнее, если важнее предсказуемость, стабильная интеграция и привычный production-пайплайн. На практике разница видна в трёх вещах: сколько токенов/sec держится под нагрузкой, как растёт latency p95 при росте concurrency и насколько болезненно сервер переживает длинные промпты.

Чек-лист перед выбором:
— если запросы короткие и их много, сначала смотрите на batching и prefill throughput;
— если нужен длинный контекст, считайте не только VRAM под веса, но и запас под KV-cache;
— если у вас несколько моделей, важнее изоляция и очереди, чем абсолютный peak speed;
— если batch size пришлось уменьшать вдвое ради стабильности, вы уже потеряли часть экономии.

Главное правило: выбирают не «лучший сервер», а сервер под профиль нагрузки. Для арбитражной автоматизации чаще выигрывает тот стек, где p95 latency предсказуемее, а память не заканчивается на первом же длинном диалоге.

Mistral и Gemma: как выбрать модель под прод без лишнего разочарования

Если нужен open-source LLM для продукта, Mistral и Gemma часто попадают в один список, но задача у них разная. Сравнивать их нужно не по хайпу, а по четырём осям: качество, скорость, цена инференса и лицензия.

— Mistral обычно выбирают, когда важны сильный instruction-following и хороший баланс latency/качество. Для коротких и средних контекстов она часто проще в эксплуатации: меньше сюрпризов в генерации, удобнее в API-обвязке, легче масштабировать через vLLM или TGI.

— Gemma чаще берут там, где нужен компактный inference-профиль и предсказуемая работа на ограниченном железе. На одной GPU разница в throughput между 2B, 7B и 9B классом ощущается сильнее, чем разница в «названии модели»: иногда более маленькая Gemma даёт лучший cost/token, чем более крупная Mistral.

Ключевая ошибка — выбирать модель только по бенчмарку на одном датасете. В проде важнее:
• стабильность на длинном промпте
• устойчивость к шаблонным инструкциям
• поведение на русскоязычных и смешанных запросах
• совместимость с квантизацией int4/gguf без заметной деградации

По лицензии тоже нельзя смотреть поверхностно: для коммерции проверяйте условия именно той ветки модели, которую собираетесь ставить в прод, включая ограничения на redistributing и use-case.

Если задача — чат, ассистент, RAG и генерация шаблонного текста, начинайте с той модели, которая лучше проходит ваши внутренние тесты на latency и качество, а не с той, у которой громче имя.

В App Store снова появилось приложение Telegram для Apple Watch

Telegram вернул приложение для Apple Watch в App Store с поддержкой сообщений, голосовых и текстовых сообщений, гифок и стикеров. После переиздания приложения в сторе можно ожидать запуска таргетированной рекламы в Telegram ADS, что открывает возможности для тестирования MVA-приложений на iOS через новый канал трафика.

➡️ Читайте на сайте: https://aff.top/blog/v-app-store-snova-poiavilos-prilozhenie-telegram-dlia-apple-watch

🧠 Ещё больше инсайтов → в канале AFF.top

DeepSeek в проде ломается не на модели, а на плохом пайплайне инференса

DeepSeek часто берут ради сильного reasoning и хорошего соотношения качество/цена, но в реальном сервисе решает не только чекпоинт.

— Сначала проверь формат задачи: если это короткие ответы, то длинный контекст и тяжелый reasoning только съедают throughput.
— Для batch-генерации и очередей почти всегда выгоднее vLLM; если нужен простой локальный запуск или CPU/GPU-микс, смотри в сторону llama.cpp.
— Квантизация ниже fp16 обязана проходить свой набор тестов: на code, math и extraction модели могут вести себя по-разному.
— Для API-сервиса отдельно меряй prompt prefill и decode, а не только общий tokens/sec: именно prefill часто убивает latency на длинных промптах.
— Не смешивай в одном endpoint задачи с разной длиной контекста без лимитов: один «монстр»-запрос портит очередь всем остальным.

Практика простая: сначала замерь качество на своих задачах, потом throughput на своем железе, и только после этого решай, какой DeepSeek и в какой квантизации пускать в прод.

vLLM и TGI ломаются не на модели, а на неправильном профиле нагрузки

Если у тебя короткие запросы, высокий параллелизм и нужен агрессивный batching — vLLM обычно даёт выше throughput за счёт paged attention и более гибкого управления KV-cache. Если важнее предсказуемость, интеграция в уже собранный inference-пайплайн и контроль за serving-логикой — TGI часто проще в эксплуатации.

Смотри не на «лучший фреймворк», а на три числа: tokens/sec на одну GPU, p95 latency и объём контекста при реальной очереди. В синтетике оба сервера выглядят бодро, но при длинных промптах и mixed load начинает решать не маркетинг, а то, как движок режет память, собирает batch и пережёвывает prefill.

Практика такая:
• vLLM — если у тебя много одновременных сессий, streaming и постоянная смена длины запросов.
• TGI — если важны стабильность, понятный deployment и интеграция с HF-стеком.
• Оба нужно тестировать на своём распределении: короткие саппорт-реплики, длинные RAG-запросы, tool-calls, несколько одинаковых пиковых окон.

Не делай вывод по одному прогону на 512 токенов. Прогони хотя бы 3 профиля: short chat, long context, burst traffic. Тогда выбор между vLLM и TGI станет не религией, а инженерным решением.

Арбитраж на вертикаль астрологии: как начать с ней работать

Астрология — белая вертикаль с низким порогом входа для CPA-арбитража. Можно создать собственного астробота через конструктор или нейросеть, подключив платежи через сервисы вроде Tribute, либо работать через партнёрки с готовыми ботами и SP-офферами. Также доступны нишевые площадки типа Bongacams с эзотериками (A. W. Empire). Трафик заливают со стандартных источников без клоачинга — Яндекс Директ, МТС Ads, ВК. Вертикаль привлекательна скромной к…

➡️ Читайте на сайте: https://aff.top/blog/arbitrazh-na-vertikal-astrologii-kak-nachat-s-nei-rabotat

🧠 Ещё больше инсайтов → в канале AFF.top

DeepSeek в проде: где модель реально экономит токены, а где её лучше не ставить

DeepSeek часто берут как «дешёвую замену», но в проде смотреть надо не на бренд, а на профиль задачи: генерация, код, классификация, длинный контекст.

— Для structured generation и code-heavy сценариев сильнее всего обычно работает связка: умеренный размер модели + жёсткий system prompt + low temperature.
— Для длинных диалогов важнее не «128k на бумаге», а реальная деградация после нескольких десятков тысяч токенов: у многих моделей качество ответов падает раньше, чем заканчивается окно.
— Для RAG DeepSeek полезен там, где нужен хороший follow-up по найденным кускам текста, но retrieval всё равно решает больше, чем сама LLM.
— Для массового API-сервиса считайте не только качество, но и throughput на вашей GPU: если модель даёт меньше токенов/sec, дёшево на токен она может стать дорогой на инфраструктуру.

Практика такая: сначала гоняете модель на своём наборе промптов, потом сравниваете quality / latency / cost / license. Если задача — чат и извлечение фактов, берите smaller variant. Если нужен сложный reasoning или код с многослойным контекстом, проверяйте старшую, но обязательно на своём железе.

Главная ошибка — выбирать DeepSeek по общему впечатлению. В проде выигрывает не «лучшая модель», а та, у которой совпали качество ответа, скорость и стоимость обслуживания.

Llama в проде: 6 проверок, которые спасают от дорогого и медленного инференса

Llama часто берут “по умолчанию”, а потом удивляются просадке по latency и качеству. Перед запуском проверьте четыре вещи: размер контекста, тип квантизации, формат сервинга и реальную длину промптов в вашем трафике. Если 90% запросов укладываются в короткий контекст, не переплачивайте за огромный KV-cache и лишнюю VRAM.

Для 8B-моделей рабочая база — fp16 для качества, int8 как компромисс, int4/gguf для дешёвого CPU или одной GPU с ограниченной памятью. На практике важнее не “максимальный размер”, а tokens/sec на вашей карте и стабильность под параллельной нагрузкой. vLLM обычно выигрывает на батчинге, TGI удобен в продакшене, llama.cpp нужен там, где критична автономность.

Отдельно смотрите на prompting: у Llama чувствительность к шаблону ответа выше, чем кажется. Один и тот же чекпоинт может давать разный output при смене system prompt, stop tokens и температуры. Если делаете fine-tune под нишу, сначала фиксируйте формат входа и метрику ошибки, а уже потом крутите LoRA.

Ещё одна типовая ошибка — сравнивать модель в вакууме. Считайте не только качество, но и стоимость 1M токенов на вашем железе, p95 latency, объём памяти под контекст и цену простоя. Брать Llama имеет смысл там, где вы готовы управлять инференсом как продуктом, а не как “чёрным ящиком”.

DeepSeek для продакшена: как не промахнуться с выбором модели и инференса

DeepSeek часто берут за сильный reasoning и нормальную цену входа, но в проде смотреть надо не на хайп, а на профиль нагрузки.

— Для чата и RAG важны не только ответы, но и поведение на длинном контексте: у больших контекстов деградация начинается раньше паспортного окна.
— Если нужен поток запросов, сравнивайте не «качество на глаз», а tokens/sec, p95 latency и max batch size на своём железе.
— Для задач с жёсткой стоимостью токена считайте throughput на одной GPU в разных квантизациях: fp16, int8, int4. Разница по экономике часто важнее разницы в бенчмарке.
— Если планируется fine-tune, проверьте, как модель держит LoRA на вашем домене: у reasoning-моделей иногда проседает стиль, даже если метрика на тесте растёт.
— Лицензия и режим использования важнее красивого демо: сначала проверяем, можно ли модель легально встраивать в коммерческий стек.

Практика простая: тестируйте DeepSeek не на одном промпте, а на пачке из 50–200 реальных запросов, где есть короткие, длинные и «грязные» кейсы. И только после этого решайте, брать ли её как основную или оставить для узкого класса задач.

vLLM и TGI ломают prod по-разному: где у каждого свой скрытый лимит

Если у тебя один и тот же промпт на 8k летает, а на 32k внезапно сыпется latency — проблема часто не в модели, а в сервере. vLLM и TGI оба умеют отдавать LLM в проде, но оптимизируют разные узкие места: один чаще выигрывает на динамическом батчинге и высокой утилизации GPU, другой — на предсказуемом пайплайне и простом прод-обвязке.

Смотри на 4 вещи:
— throughput в tokens/sec на одной GPU, а не “сколько RPS держит”
— p95/p99 latency при смешанном трафике, а не только среднее
— поведение на длинном контексте: 16k/32k/64k часто деградируют неравномерно
— memory fragmentation: если сервис живёт под постоянным churn запросов, часть VRAM просто уходит в мусор

vLLM обычно лучше, когда важна плотная загрузка железа и много параллельных сессий с разной длиной промптов. TGI удобнее, когда нужен более прямолинейный деплой, стабильный API и меньше сюрпризов в эксплуатационке. Но оба проиграют, если ты не ограничил max_tokens, не настроил batching и не посчитал, сколько контекста реально нужно бизнес-задаче.

Правило простое: сначала замерь на своём профиле трафика, потом выбирай движок. Иначе можно получить “быстрый” сервер, который в проде сжирает VRAM, режет контекст и делает cost/token хуже, чем у внешнего API.