WEBVTT

00:00:00.000 --> 00:00:03.680
Ваш процесс автоматизации с использованием и провалился не из-за самого «и», а потому что он вам доверял.

00:00:03.800 --> 00:00:05.380
Это-то, чего никто не хочет слышать.

00:00:05.520 --> 00:00:11.160
Вы создали автоматизацию, назвали ее «умной», а затем загрузили в нее недоработанные данные из формы, заполненные кем-то в пятницу днем.

00:00:11.320 --> 00:00:18.740
Вы предположили, что автоматизация означает надежность, тогда как на самом деле автоматизация лишь усиливает ваши ошибки быстрее и с большей уверенностью, чем это мог бы сделать любой стажер.

00:00:18.900 --> 00:00:20.960
Позвольте мне перевести это на язык бизнеса.

00:00:21.100 --> 00:00:24.100
Ваш процесс в Капайлот Студия рухнул не из-за ошибки Майкрософт.

00:00:24.100 --> 00:00:27.820
Он рухнул, потому что некорректные входные данные были восприняты как истина в последней инстанции.

00:00:28.060 --> 00:00:33.040
Отсутствующие поле здесь, неправильно набранный адрес электронной почты там, и внезапно ваша база данных выглядит так, будто ее составляли малыши.

00:00:33.100 --> 00:00:34.200
И не вел себя неправильно.

00:00:34.360 --> 00:00:36.780
Он сделал именно то, что вы ему сказали абсолютно неправильно.

00:00:36.900 --> 00:00:37.980
Так чего же не хватает?

00:00:38.240 --> 00:00:38.640
Управление.

00:00:38.980 --> 00:00:39.840
Настоящие проверки.

00:00:40.040 --> 00:00:45.340
Момента, когда человек останавливает автоматизацию на достаточно долгое время, чтобы подтвердить реальность, прежде чем боты начнут работать дальше.

00:00:45.520 --> 00:00:48.380
Вот тут-то и вступает в действие запрос информации RFI.

00:00:48.380 --> 00:00:53.140
Представьте его как человеческий брендмауэр, который не позволяет некорректным данным сбить вашу автоматизацию.

00:00:53.300 --> 00:00:57.600
Он изолирует их, заставляет человека проверить, и только после этого позволяет потоку продолжиться.

00:00:57.740 --> 00:01:05.580
К концу этого процесса вы поймете, почему постоянно возникают несоответствия данных, нулевые циклы и бессмысленные действия I, и как один небольшой механизм соответствия устраняет все три.

00:01:05.720 --> 00:01:06.080
Спойлер.

00:01:06.260 --> 00:01:10.860
Проблема не в том, что ваши потоки слишком автоматизированы, а в том, что они недостаточно управляемы.

00:01:10.980 --> 00:01:13.280
Грязный секрет автоматизации с помощью I.

00:01:13.440 --> 00:01:14.500
I любит точность.

00:01:14.700 --> 00:01:15.960
Пользователи любят хаос.

00:01:15.960 --> 00:01:19.280
Это главное слепое пятно в управлении корпоративной автоматизацией.

00:01:19.380 --> 00:01:28.060
Каждая энтузиастка Pilot Studio считает, что его потоки безупречны, потому что с ними справляется I, на самом деле, и обрабатывает все, что вы ему даете, хорошее или плохое, без осуждения.

00:01:28.200 --> 00:01:29.780
Он послушен, а не интеллектуален.

00:01:29.900 --> 00:01:33.420
Он не спрашивает, уверены ли мы, что у этого посетителя есть допуск к работе в лаборатории.

00:01:33.640 --> 00:01:38.080
Система просто бронирует встречу, обновляет запись и молится, чтобы юридическая команда никогда об этом не узнала.

00:01:38.220 --> 00:01:41.260
Представьте себе процесс, созданный для управления запросами на доступ в здание.

00:01:41.260 --> 00:01:45.360
Он принимает ответы от сотрудников или внешних посетителей и добавляет их в таблицу Датаверс.

00:01:45.480 --> 00:01:46.920
В вашем представлении все просто.

00:01:47.100 --> 00:01:50.380
В реальности же кто-то оставляет поле «цель визита» пустым или вводит «встреча».

00:01:50.380 --> 00:01:52.140
Это не цель, это просто пожатие плечами.

00:01:52.260 --> 00:01:55.780
Но ваша автоматизация считывает это как допустимое и с радостью пересылает запрос в службу безопасности.

00:01:55.940 --> 00:01:56.380
Поздравляем!

00:01:56.540 --> 00:02:00.480
Вы разрешили неизвестному человеку войти в здание с ограниченным доступом для проведения встречи.

00:02:00.580 --> 00:02:05.520
Когда аудиторская группа проверит это, они назовут ваш процесс угрозой для соблюдения нормативных требований, а не техническим чудом.

00:02:05.520 --> 00:02:08.700
Именно так большинство рабочих процессов, управляемых ИИ, терпит неудачу.

00:02:08.800 --> 00:02:11.680
Не из-за логических ошибок, а из-за слепого доверия к человеческому вводу.

00:02:11.980 --> 00:02:14.180
Автоматизация предполагает структуру там, где ее нет.

00:02:14.300 --> 00:02:16.240
Она воспринимает утверждение вместо фактов.

00:02:16.400 --> 00:02:18.860
Она не проверяет достоверность, потому что вы ей этого не сказали.

00:02:18.980 --> 00:02:25.660
И когда эти ошибочные данные распространяются по Датаверс, панелям мониторинга по ОРБИ или даже вашей системе управления персоналом, они заражают каждую последующую запись.

00:02:25.780 --> 00:02:28.780
То, что начиналось как удобство, превращается в системную коррупцию.

00:02:28.780 --> 00:02:31.880
Команды по управлению называют это пробелом в надежности данных.

00:02:32.020 --> 00:02:35.560
Каждое автоматизированное решение должно основываться на проверенных входных данных.

00:02:35.740 --> 00:02:39.040
Без этой контрольной точки вы не автоматизируете, а ускоряете ошибки.

00:02:39.200 --> 00:02:45.860
Ирония заключается в том, что большинство людей проектируют потоки таким образом, чтобы исключить человеческое вмешательство, тогда как более разумным шагом было бы стратегически добавить его в нужном месте.

00:02:45.980 --> 00:02:49.220
Поэтому Microsoft наконец-то решила сделать ваши потоки менее доверчивыми.

00:02:49.400 --> 00:02:53.940
Запрос информации — это их способ внести проверку на адекватность в изначально наивную систему.

00:02:53.940 --> 00:02:59.700
Он приостанавливает выполнение на полпути и говорит «Подождите, это должен подтвердить человек, прежде чем мы продолжим».

00:02:59.700 --> 00:03:03.420
Этот момент ожидания — не неэффективность, это дисциплина управления в действии.

00:03:03.580 --> 00:03:09.400
Если посмотреть на это с такой точки зрения, автоматизация без проверки — это не прогресс, а нарушение политики с блестящим пользовательским интерфейсом.

00:03:09.500 --> 00:03:15.820
Каждое непроверенное поле, каждый пустой выпадающий список, каждое текстовое поле, воспринимаемое как истина, является потенциальным нарушением требований соответствия.

00:03:15.980 --> 00:03:21.620
Функция RFI существует именно для того, чтобы превратить хаос обратно в порядок, обрабатывая каждую форму Outlook по отдельности.

00:03:21.620 --> 00:03:30.100
И как только вы увидите, как один некорректный поток данных разрушает ваше хранилище данных, вы оцените этот момент, потому что альтернатива — это не более быстрая автоматизация, а более быстрая катастрофа.

00:03:30.260 --> 00:03:33.200
Здесь на помощь приходит RFI — человек в цикле обработки.

00:03:33.380 --> 00:03:38.300
Запрос информации, сокращенно RFI — это момент, когда ваша автоматизация учится смирению.

00:03:38.460 --> 00:03:44.120
Это эквивалент цифровой руки в Copilot Studio, которая говорит «Подождите, мне нужен человек, прежде чем я все испорчу».

00:03:44.120 --> 00:03:48.600
И да, именно это она и делает. Это не просто заполнитель формы или расширенная подсказка.

00:03:48.720 --> 00:03:53.800
Это контрольная точка соответствия, которая удерживает грань между чистыми проверенными данными и полным хаосом.

00:03:53.940 --> 00:03:55.280
Вот что это такое на самом деле.

00:03:55.500 --> 00:04:02.200
Действие RFI находится внутри вашего потока обработки данных и останавливает его выполнение до тех пор, пока кто-то, реальный человек, не ответит на сообщение Outlook, требующее действия.

00:04:02.320 --> 00:04:04.480
Это сообщение не является пассивным уведомлением.

00:04:04.480 --> 00:04:11.120
Это встроенная мини-форма прямо в Outlook, разработанная с обязательными полями, которые получатель должен заполнить, прежде чем процесс продолжится.

00:04:11.240 --> 00:04:17.040
Пока он обдумывает свои ответы, ваша автоматизация просто находится в режиме ожидания, как хорошо обученный дворецкий, ожидающий инструкций.

00:04:17.200 --> 00:04:22.320
Только когда поля заполнены, предоставлены все необходимые значения, отмечены все флажки, процесс продолжается.

00:04:22.500 --> 00:04:25.080
Представьте это как условный доступ для рабочих процессов.

00:04:25.180 --> 00:04:28.260
Вы бы не позволили непроверенному компьютеру подключиться к вашей корпоративной сети.

00:04:28.440 --> 00:04:31.400
Так почему же вы позволяете непроверенным данным попадать в вашу таблицу Dataverse?

00:04:31.400 --> 00:04:33.760
RFI обеспечивает именно такую остановку.

00:04:33.760 --> 00:04:37.320
Выполнение приостанавливается до тех пор, пока реальность не будет соответствовать политике.

00:04:37.440 --> 00:04:38.520
И вот в чем хитрость.

00:04:38.640 --> 00:04:39.480
Это синхронно.

00:04:39.600 --> 00:04:41.840
Это означает, что процесс ждет истины.

00:04:41.980 --> 00:04:43.680
Он не гадает, не делает выводов.

00:04:43.820 --> 00:04:47.880
Он просто ждет, пока ему не скажут однозначно, эти данные готовы к отправке.

00:04:48.020 --> 00:04:51.680
Теперь, возможно, заманчиво предположить, что ваши подсказки и уже обрабатывают это.

00:04:51.820 --> 00:04:53.920
В конце концов, подсказки звучат интеллектуально.

00:04:54.060 --> 00:04:57.260
Они проверяют детали, обобщают контент, даже обнаруживают отсутствующие поля.

00:04:57.380 --> 00:04:59.020
Но подсказки лишь интерпретируют информацию.

00:04:59.020 --> 00:05:00.620
Они считают, что она имеет смысл.

00:05:00.780 --> 00:05:01.780
Им не хватает авторитета.

00:05:01.780 --> 00:05:03.780
Запросы на информацию RFI подтверждают.

00:05:03.840 --> 00:05:06.400
Они превращают, выглядят нормально, официально подтверждено.

00:05:06.520 --> 00:05:08.300
Подсказки приблизительно понимают информацию.

00:05:08.560 --> 00:05:10.260
RFI обеспечивают соблюдение требований.

00:05:10.440 --> 00:05:13.540
В сочетании одна проверяет логику, другая — подотчетность.

00:05:13.740 --> 00:05:14.580
Вот реальный пример.

00:05:14.740 --> 00:05:20.400
В процессе обработки запросов на доступ посетителей использовался запрос на основе и для проверки введенных данных из Microsoft Forms.

00:05:20.540 --> 00:05:26.120
Если посетитель планировал посетить лабораторию и проверял информацию о безопасности, тип работы, допуск и защитное снаряжение.

00:05:26.120 --> 00:05:29.480
Если пользователь пропускал этот раздел, запрос помечал его как неполный.

00:05:29.560 --> 00:05:30.880
И тут появляется RFI.

00:05:31.020 --> 00:05:33.360
Процесс автоматически генерировал сообщение для отправителя.

00:05:33.500 --> 00:05:37.120
«Пожалуйста, предоставьте подробную информацию о безопасности перед подтверждением доступа».

00:05:37.120 --> 00:05:41.620
Получатель открывал сообщение в Outlook, вводил необходимую информацию и нажимал «Отправить».

00:05:41.620 --> 00:05:47.900
Только после этого процесс обработки запроса агентом продолжал работу, обновляя запись в датаверс, отмечая пропуск как действительный и обеспечивая спокойное молчание ваших аудиторов.

00:05:47.900 --> 00:05:51.540
И да, можно назначить нескольких пользователей, побеждает тот, кто первым отреагирует.

00:05:51.660 --> 00:05:57.300
Последующие попытки блокируются как избыточные, что обеспечивает надежность на основе временных меток и предотвращает противоречивые изменения.

00:05:57.440 --> 00:06:01.560
Каждая отправленная форма запроса информации, RFI, оставляет за собой тщательно очлеживаемый след.

00:06:01.720 --> 00:06:03.560
Кто ответил, когда, что он ввел?

00:06:03.660 --> 00:06:06.820
Это бесценно для команд управления, одержимых очлеживаемостью.

00:06:06.940 --> 00:06:10.280
RFI исправляют не только некорректные данные, но и нарушенную подотчетность.

00:06:10.440 --> 00:06:13.780
Они гарантируют, что никто не сможет пожать плечами и сказать «О, это сделала система».

00:06:13.780 --> 00:06:18.720
Потому что если данные прошли через шлюз RFI, кто-то где-то должен был нажать кнопку «Отправить», указав свое имя.

00:06:18.840 --> 00:06:21.100
Это цифровая ответственность на уровне формы.

00:06:21.260 --> 00:06:26.060
Вот как вы возвращаете подотчетность в автоматизацию осознанно, четко, с гордостью.

00:06:26.160 --> 00:06:31.220
RFI не замедляет вас, он предотвращает столкновение вашего рабочего процесса с препятствием в виде несоответствия требованиям.

00:06:31.280 --> 00:06:38.020
И теперь, когда вы знаете, что это делает, давайте поговорим о том, почему эта небольшая пауза является самым важным актом управления, который вы когда-либо добавите в автоматизацию.

00:06:38.020 --> 00:06:40.640
Почему управление начинается с человеческой проверки?

00:06:40.640 --> 00:06:45.720
Автоматизация никогда не предполагала исключение людей из процесса, она предполагала исключение их лени.

00:06:45.860 --> 00:06:50.740
И все же, в погоне за автоматизацией всего, мы решили, что проверка является необязательной.

00:06:50.820 --> 00:06:51.380
Это не так.

00:06:51.560 --> 00:06:58.200
Каждое заслуживающее доверие автоматизация включает в себя точку подтверждения человеком, момент, когда кто-то поднимает палец и говорит «Да, это верно».

00:06:58.200 --> 00:07:02.280
В противном случае вы строите не бизнес-процесс, а фабрику слухов с машинной эффективностью.

00:07:02.280 --> 00:07:10.860
Специалисты по управлению понимают это инстинктивно, потому что любая система соответствия ISO, SOC, GDPR, выберите любую аббревиатуру, вращается вокруг очлеживаемых точек принятия решений.

00:07:11.000 --> 00:07:11.840
Кто что одобрил?

00:07:11.960 --> 00:07:13.100
Когда это было сделано?

00:07:13.240 --> 00:07:14.680
При каких условиях данных?

00:07:14.820 --> 00:07:18.680
Это не бурократические вопросы, это каркас обоснованной автоматизации.

00:07:18.900 --> 00:07:23.260
Запрос информации RFI вставляет эти моменты, на которые можно ответить прямо в ваш рабочий процесс.

00:07:23.260 --> 00:07:29.380
Без него ваш аудиторский отчет будет похож на детективный роман, полный событий, но без понимания того, кто на самом деле их вызвал.

00:07:29.560 --> 00:07:34.200
Чтобы увидеть разницу, представьте RFI как цифровой лист подтверждения, встроенный в Outlook.

00:07:34.380 --> 00:07:40.200
Процесс останавливается до тех пор, пока не будет получена электронная, автоматическая и зарегистрированная подпись человека.

00:07:40.380 --> 00:07:45.540
Когда пользователь нажимает кнопку «Отправить», записывается его ответ, адрес электронной почты и отметка времени.

00:07:45.540 --> 00:07:53.640
Это означает, что каждый последующий шаг автоматизации от одобрения доступа посетителей до регистрации транзакций связан с подтвержденным действием человека.

00:07:53.840 --> 00:07:58.580
Вы можете отследить происхождение данных вплоть до человека достаточно упрямого, чтобы оставить поле пустым.

00:07:58.740 --> 00:08:02.180
В аудите на соответствие требованиям это не просто полезно, это залог выживания.

00:08:02.360 --> 00:08:03.780
Теперь поговорим о надежности.

00:08:04.100 --> 00:08:08.600
Автоматизация страдает от того, что инженеры называют «тихими сбоями» невидимыми поломками.

00:08:08.800 --> 00:08:13.660
Значение пропадает, условие дает сбой, и никто этого не замечает, пока результат не станет выглядеть абсурдно.

00:08:13.660 --> 00:08:16.140
Запросы на информацию RFI убивают тишину.

00:08:16.280 --> 00:08:17.960
Они вводят звуковой контрольный пункт.

00:08:18.040 --> 00:08:20.840
Пропущенное поле не остается незамеченным, оно останавливает процесс.

00:08:21.060 --> 00:08:23.460
Никаких пропущенных форм, никаких подстановочных символов.

00:08:23.560 --> 00:08:27.060
Человек получает сообщение, требующее внимания, прежде чем машина продолжит работу.

00:08:27.280 --> 00:08:29.900
Специалисты по управлению называют это превентивным контролем.

00:08:30.060 --> 00:08:35.840
Обычные пользователи называют это надоедливым присмотром, но именно эти пользователи обычно позже пишут извинения в отдел соответствия.

00:08:36.000 --> 00:08:36.840
Вот в чем прелесть.

00:08:37.060 --> 00:08:41.160
Внедряя человеческую проверку, вы превращаете надежность из догадок в математику.

00:08:41.160 --> 00:08:46.300
Вы точно знаете, сколько потоков завершено с проверенными данными, потому что об этом сообщают действия RFI.

00:08:46.420 --> 00:08:49.000
Каждая из них становится измеримым узлом подотчетности.

00:08:49.220 --> 00:08:53.520
Организация переходит от «я думаю, что наши потоки стабильны, мы можем это доказать».

00:08:53.520 --> 00:08:57.100
Это зрелость управления, определяемая не бурократией, а телеметрией.

00:08:57.280 --> 00:09:02.340
Если отбросить сарказм, этот принцип человеческого подтверждения не старомоден, он вне времени.

00:09:02.680 --> 00:09:03.940
Подумайте о производстве.

00:09:04.140 --> 00:09:06.100
Машины собирают, инспекторы проверяют.

00:09:06.220 --> 00:09:07.300
Подумайте о финансах.

00:09:07.460 --> 00:09:09.540
Алгоритмы вычисляют, бухгалтеры подписывают.

00:09:09.540 --> 00:09:12.120
Автоматизация без контроля – это незавершенное уравнение.

00:09:12.340 --> 00:09:16.520
Действие RFI дает Copilot Studio недостающую половину, проверенную пользователем контрольную сумму.

00:09:16.540 --> 00:09:19.040
Это вносит дисциплину туда, где раньше было только удобство.

00:09:19.180 --> 00:09:20.820
И да, это немного замедляет вас.

00:09:20.980 --> 00:09:23.240
Это задержка, это преимущество, а не недостаток.

00:09:23.360 --> 00:09:28.560
Скорость без проверки – это как изда на спортивном автомобиле без тормозов, захватывающие ощущения до тех пор, пока не столкнешься с препятствием в виде стены соответствия.

00:09:28.700 --> 00:09:33.280
Человек, участвующий в процессе, выступает в роли тормозной системы, рассеивая кинетический хаос в структурированные данные.

00:09:33.280 --> 00:09:36.060
Когда пауза заканчивается, автоматизация снова ускоряется.

00:09:36.200 --> 00:09:39.180
Только теперь она движется в направлении, которое можно защитить в суде.

00:09:39.280 --> 00:09:41.420
Параллель с контролем качества данных очевидна.

00:09:41.540 --> 00:09:46.900
В корпоративном управлении проверка – это не недоверие к создателям данных, а защита систем, которые от них зависят.

00:09:47.000 --> 00:09:53.540
В тот момент, когда ответы на запросы информации RFI попадают в датаверс, они становятся проверяемыми фактами, а не непроверяемыми текстовыми полями.

00:09:53.660 --> 00:09:59.280
Этот переход от субъективного к объективному превращает автоматизированный процесс из удобного в готовый к аудиту.

00:09:59.280 --> 00:10:05.120
А что действительно умно? Сочетание проверки RFI с проверкой с помощью генеративного ИИ обеспечивает двойную гарантию.

00:10:05.280 --> 00:10:07.800
ИИ проверяет логику, человек подтверждает реальность.

00:10:07.980 --> 00:10:15.940
Две линзы, одна истина. Это и есть управление в стереорежиме, и оно начинается в тот момент, когда вы решаете, что автоматизация без подотчетности – это не умно, а безрассудно.

00:10:16.060 --> 00:10:18.800
Четвертый раздел – цикл управления ИИ и RFI.

00:10:18.960 --> 00:10:22.780
Проверка ИИ – это умный процесс. Вы вводите текст, а он выдает оценку.

00:10:22.940 --> 00:10:26.940
Истина, ложь, допустимость, неполнота – это машинный эквивалент поднятой брови.

00:10:26.940 --> 00:10:31.860
Но оценка без авторитета – это все еще догадка. А в автоматизации догадка – враг.

00:10:31.980 --> 00:10:37.180
Вот почему сочетание подсказок и с действием RFI создает то, что я называю циклом управления.

00:10:37.400 --> 00:10:41.100
Замкнутый контур между искусственным рассуждением и подтверждением человеком.

00:10:41.200 --> 00:10:45.880
ИИ предлагает – люди подтверждают. Вместе они создают надежность, которую вы можете реально доказать.

00:10:46.020 --> 00:10:46.980
Вот как это происходит.

00:10:47.180 --> 00:10:48.900
Агент Капайлот Студия получает запрос.

00:10:49.080 --> 00:10:52.020
Например, из формы Майкрософт, запрашивающий доступ для посетителей.

00:10:52.220 --> 00:10:53.340
Детали выглядят безобидно.

00:10:53.340 --> 00:10:56.080
Джеймс посещает штаб-квартиру для совещания по проекту.

00:10:56.200 --> 00:10:59.600
Подсказка и оценивает ее с помощью созданной вами логики проверки.

00:10:59.760 --> 00:11:03.740
Включает ли она тип совещания, продолжительность, данные для обеспечения безопасности.

00:11:03.920 --> 00:11:07.500
Ответ модели содержит JSON-данные, допустимость, истина или ложь,

00:11:07.580 --> 00:11:11.280
и причину отсутствия ожидаемой продолжительности или наличия необходимой информации.

00:11:11.440 --> 00:11:12.960
Это первая контрольная точка.

00:11:13.160 --> 00:11:15.640
Вердикт подсказки – это не приказ, а доказательство.

00:11:15.780 --> 00:11:18.960
Теперь запрос информации RFI продолжает работу там, где остановился И.

00:11:18.960 --> 00:11:22.620
Если ответ запроса возвращает false, поток переходит к действию RFI.

00:11:22.860 --> 00:11:24.340
Автоматизация приостанавливается.

00:11:24.560 --> 00:11:26.540
Она формирует сообщение для Outlook с заголовком.

00:11:26.680 --> 00:11:29.880
Например, требуются дополнительные сведения для запроса доступа в штаб-квартиру.

00:11:30.020 --> 00:11:32.980
В этом сообщении точно указаны недостающие поля, выявленные И,

00:11:33.080 --> 00:11:37.820
подробное описание, ожидаемая продолжительность и любые другие необходимые данные для соответствия требованиям.

00:11:37.960 --> 00:11:42.180
Система назначает его первоначальному заявителю, используя его идентификатор из формы.

00:11:42.340 --> 00:11:47.380
Сообщение попадает в его почтовый ящик, и внезапно рабочий процесс, который казался полностью автоматизированным,

00:11:47.380 --> 00:11:50.200
вежливо сообщает «Вы что-то упустили. Исправьте это».

00:11:50.200 --> 00:11:53.520
Когда он отвечает, эти данные не просто исправляют запись.

00:11:53.980 --> 00:11:55.520
Они подтверждают исправление.

00:11:55.720 --> 00:11:59.140
RFI фиксирует метку времени, идентификатор пользователя и новый контент,

00:11:59.280 --> 00:12:04.100
а затем сохраняет эти данные в виде структурированных выходных данных с ключом регистрируемых неизменяемых.

00:12:04.200 --> 00:12:10.360
Поток агента возобновляется, обновляет строку в Dataverse и изменяет статус «Требуется информация» на «Действительно».

00:12:10.360 --> 00:12:15.120
В этот момент вы не только завершили рабочий процесс, но и создали проверяемый артефакт управления.

00:12:15.300 --> 00:12:16.860
Каждый результат документируется.

00:12:17.180 --> 00:12:21.560
Первоначальная оценка и «Ручная корректировка» и окончательное подтвержденное состояние.

00:12:21.740 --> 00:12:23.640
Сравните это со сценарием без RFI.

00:12:23.780 --> 00:12:25.840
И все равно будет отмечать недостающие детали.

00:12:26.040 --> 00:12:26.560
Но что потом?

00:12:26.720 --> 00:12:29.900
Он может выдать ошибку, отправить расплывчатое электронное письмо или просто зациклиться,

00:12:30.000 --> 00:12:32.600
задавая один и тот же вопрос бесконечно, пока кто-то не исправит это вручную.

00:12:32.720 --> 00:12:34.580
Это печально известный «Тихий сбой».

00:12:34.580 --> 00:12:37.820
Технический процесс выполнился, но его результатам нельзя доверять.

00:12:38.080 --> 00:12:40.540
Интеграция RFI полностью исключает тишину.

00:12:40.680 --> 00:12:43.500
Процесс должен визуально ждать поступления подтвержденных данных.

00:12:43.640 --> 00:12:46.140
Это не просто отказоустойчивость, это защита от сбоев по своей сути.

00:12:46.280 --> 00:12:47.980
Представьте это как физическую безопасность.

00:12:48.100 --> 00:12:50.100
Подсказка «И» — это камера видеонаблюдения.

00:12:50.240 --> 00:12:51.620
Она наблюдает и анализирует.

00:12:51.740 --> 00:12:53.240
RFI — это запертая дверь.

00:12:53.380 --> 00:12:56.540
Она отказывает во входе, пока вы не предъявите подтвержденные учетные данные.

00:12:56.700 --> 00:12:57.780
Вам нужны оба варианта.

00:12:57.780 --> 00:12:59.700
Камеры сдерживают неправомерное поведение.

00:12:59.940 --> 00:13:01.060
Замки предотвращают его.

00:13:01.200 --> 00:13:03.960
В сфере управления подсказки обнаруживают несоответствие.

00:13:04.160 --> 00:13:06.220
RFI предотвращают их распространение.

00:13:06.460 --> 00:13:09.220
Вместе они превращают хаотичную, подверженную ошибкам автоматизацию

00:13:09.220 --> 00:13:12.000
в двухфакторный процесс аутентификации для обеспечения качества данных.

00:13:12.120 --> 00:13:15.400
Каждый результат запроса информации RFI представляет собой миниатюрную запись аудита.

00:13:15.560 --> 00:13:17.800
Объект GSON включает не только предоставленные значения,

00:13:17.940 --> 00:13:20.500
но и информацию о том, кто их предоставил, когда и из какого контекста.

00:13:20.660 --> 00:13:23.180
Специалисты по соблюдению нормативных требований высоко ценят это,

00:13:23.180 --> 00:13:26.200
поскольку это преобразует абстрактную логику проверки в ощутимые доказательства.

00:13:26.200 --> 00:13:30.080
Теперь вы можете продемонстрировать, что решения вашего и никогда не были автономными.

00:13:30.260 --> 00:13:32.560
Они были подтверждены человеком в режиме реального времени.

00:13:32.760 --> 00:13:35.120
В этом разница между продуманной демонстрацией и готовой к использованию

00:13:35.120 --> 00:13:36.620
в масштабах предприятия системы управления.

00:13:36.840 --> 00:13:40.340
Лучшие практики управления Power Platform подчеркивают именно эту двойную проверку,

00:13:40.520 --> 00:13:42.980
автоматизированное рассуждение плюс подтверждение человеком.

00:13:43.120 --> 00:13:44.640
Это обеспечивает повторяемость.

00:13:44.820 --> 00:13:48.020
Вы можете запустить тот же процесс завтра и получить проверяемые результаты.

00:13:48.020 --> 00:13:49.680
Это обеспечивает обоснованность.

00:13:49.840 --> 00:13:52.360
Если регулирующие органы спросят, как было принято решение,

00:13:52.540 --> 00:13:53.920
у вас будет буквальное доказательство.

00:13:53.920 --> 00:13:55.520
И это обеспечивает надежность.

00:13:55.680 --> 00:13:57.900
Каждый запуск процесса генерирует согласованные результаты

00:13:57.900 --> 00:14:00.900
с измеренной степенью достоверности, а не на основе оптимистичных предположений.

00:14:01.060 --> 00:14:04.400
Да, такой подход вносит задержку, обычно от 10 до 15 секунд ожидания,

00:14:04.600 --> 00:14:06.400
пока пользователь завершит свой запрос информации.

00:14:06.520 --> 00:14:08.500
Но эта короткая пауза предотвращает многочасовую,

00:14:08.640 --> 00:14:10.320
а иногда и многодневную очистку после инцидента,

00:14:10.460 --> 00:14:12.340
когда некорректные данные распространяются бесконтрольно.

00:14:12.520 --> 00:14:15.480
Люди жалуются, что RFI замедляет их автоматизированные процессы.

00:14:15.480 --> 00:14:18.280
Это все равно, что жаловаться на тормоза, замедляющие вашу машину.

00:14:18.400 --> 00:14:21.160
Они замедляют ее намеренно, чтобы вы могли продолжать ехать завтра.

00:14:21.280 --> 00:14:24.680
В конечном итоге, цикл RFI с использованием и не просто исправляет рабочие процессы,

00:14:24.780 --> 00:14:26.120
он перестраивает систему подотчетности.

00:14:26.260 --> 00:14:28.680
Он учит вашу автоматизацию быть скептически настроенной.

00:14:28.840 --> 00:14:31.400
И обнаруживает аномалии, RFI проверяет исправление,

00:14:31.580 --> 00:14:33.860
и вместе они рассматривают данные не как одноразовый текст,

00:14:34.040 --> 00:14:35.220
а как контролируемый инвентарь.

00:14:35.340 --> 00:14:38.120
Каждый элемент проверяется, регистрируется и может быть извлечен.

00:14:38.320 --> 00:14:40.540
Управление перестает быть бурократической затеей.

00:14:40.540 --> 00:14:42.640
Оно становится инженерной особенностью.

00:14:42.640 --> 00:14:45.900
И именно в этом цикле, медленном, обдуманном, подотчетном,

00:14:46.120 --> 00:14:48.400
начинается настоящая надежность предприятия.

00:14:48.700 --> 00:14:50.940
Распространенные ошибки при игнорировании RFI.

00:14:51.140 --> 00:14:54.860
Давайте поговорим о том, что происходит, когда вы делаете вид, что RFI не существует.

00:14:55.000 --> 00:14:56.300
Спойлер, ничего хорошего.

00:14:56.460 --> 00:14:59.020
Потоки без RFI похожи на подростков с ключами от машины,

00:14:59.200 --> 00:15:01.800
технически работоспособные, но катастрофически бесконтрольные.

00:15:01.940 --> 00:15:04.260
Они принимают любые данные, которые вы им предоставляете,

00:15:04.260 --> 00:15:06.000
а затем уверенно движутся к катастрофе.

00:15:06.120 --> 00:15:09.280
Начнем с наиболее предсказуемого сбоя нулевых входных данных.

00:15:09.280 --> 00:15:13.900
Ваш поток сталкивается с пустым полем, скажем, с количеством гостей для посещения объекта,

00:15:14.020 --> 00:15:15.640
и спокойно пытается его обработать.

00:15:15.760 --> 00:15:17.820
Это нулевое значение распространяется дальше,

00:15:18.100 --> 00:15:21.780
нарушая условия, пропуская параллельные ветви и путая все зависимые действия.

00:15:21.960 --> 00:15:25.460
В итоге вы получаете потоки, которые, согласно Power Automate, проходят успешно,

00:15:25.540 --> 00:15:28.380
но выдают результаты, которые не прошли бы даже базовую проверку логики.

00:15:28.380 --> 00:15:30.880
Затем вы получаете эти фантомные записи в датаверс,

00:15:31.000 --> 00:15:33.560
пустые строки с метками времени, но без фактических данных,

00:15:33.740 --> 00:15:35.760
засоряющие ваши таблицы, как цифровые пыль.

00:15:35.940 --> 00:15:37.600
Далее идут неточные подтверждения.

00:15:37.600 --> 00:15:40.180
Без проверки RFI ваша автоматизация предполагает,

00:15:40.360 --> 00:15:42.640
что человек, заполнивший форму, понял все правила.

00:15:42.780 --> 00:15:43.340
Это не так.

00:15:43.440 --> 00:15:46.360
В результате вы получаете разрешение на доступ посетителей без допуска к секретной информации,

00:15:46.480 --> 00:15:47.700
подтверждение расходов без центров затрат

00:15:47.700 --> 00:15:50.000
или добавление новых сотрудников без подтвержденных удостоверений личности.

00:15:50.140 --> 00:15:51.800
В хороший день это приводит к доработке.

00:15:51.940 --> 00:15:53.840
В плохой день — к юридической ответственности.

00:15:53.960 --> 00:15:56.060
Помните, что автоматическое подтверждение, внесенное в датаверс,

00:15:56.180 --> 00:15:58.260
становится частью вашей системы отслеживания соответствия требованиям.

00:15:58.340 --> 00:16:00.160
Как только данные заблокированы, аудиторам уже все равно,

00:16:00.340 --> 00:16:01.680
что это произошло из-за особенностей процесса.

00:16:01.680 --> 00:16:03.960
Они назовут это «сбоем контроля» и будут правы.

00:16:04.040 --> 00:16:07.420
И да, искаженные данные в датаверс естественным образом вытекают из этого хаоса.

00:16:07.520 --> 00:16:09.580
Каждый раз, когда проникает неполная информация,

00:16:09.780 --> 00:16:11.200
связи между таблицами нарушаются.

00:16:11.340 --> 00:16:13.660
Поиск не удается, зависимые запросы возвращают бессмыслицу,

00:16:13.780 --> 00:16:15.920
а на панелях мониторинга внезапно отображаются итоговые суммы,

00:16:16.000 --> 00:16:17.740
от которых финансовый отдел чуть не подавился бы кофе.

00:16:17.880 --> 00:16:21.740
Без контрольных точек RFI ни один из этих пробелов не обнаруживается во время создания данных.

00:16:21.880 --> 00:16:23.020
Они просто накапливаются,

00:16:23.220 --> 00:16:25.640
пока сезон отчетности не превратится в поиск виновных.

00:16:25.640 --> 00:16:29.780
Затем возникает бесконечный цикл уточнений и крика помощи от автоматизации.

00:16:30.000 --> 00:16:31.660
Ваш запрос и выявляет недостающие детали,

00:16:31.820 --> 00:16:34.220
отправляет еще один запрос, получает еще один расплывчатый ответ,

00:16:34.460 --> 00:16:36.720
снова зацикливается и в конце концов истекает время ожидания.

00:16:36.880 --> 00:16:39.140
Это как разговор с чат-ботом, который забыл тему,

00:16:39.360 --> 00:16:40.880
но отказывается прекратить печатать.

00:16:41.000 --> 00:16:43.420
Все потому, что вы не предоставили процессу возможность приостановиться

00:16:43.420 --> 00:16:45.580
и дождаться окончательных исправлений, проверенных человеком.

00:16:45.700 --> 00:16:46.760
Вот что делает RFI.

00:16:46.900 --> 00:16:49.020
Он разрывает этот цикл, удерживая выполнение в заложниках до тех пор,

00:16:49.160 --> 00:16:49.980
пока не будет установлена правда.

00:16:49.980 --> 00:16:52.940
Все негативные последствия игнорирования запросов на информацию RFI для бизнеса

00:16:52.940 --> 00:16:53.900
приводят к негативным последствиям.

00:16:53.980 --> 00:16:55.620
Увеличивается риск нарушения нормативных требований,

00:16:55.760 --> 00:16:57.280
поскольку невозможно доказать, кто что одобрил.

00:16:57.420 --> 00:16:59.060
Аудиторские журналы становятся ненадежными,

00:16:59.240 --> 00:17:01.320
так как цепочка доказательств начинается с неполных данных.

00:17:01.500 --> 00:17:03.240
Если вы думаете, что аудиторы получают удовольствие

00:17:03.240 --> 00:17:05.180
от интерпретационного восстановления недостающих значений,

00:17:05.260 --> 00:17:06.460
вы явно никогда с ними не сталкивались.

00:17:06.580 --> 00:17:08.040
А теперь давайте оценим стоимость.

00:17:08.260 --> 00:17:10.600
Каждый раз, когда автоматизация незаметно дает сбой

00:17:10.600 --> 00:17:12.000
из-за некорректных входных данных,

00:17:12.000 --> 00:17:13.720
кто-то должен вручную выявить проблему,

00:17:13.960 --> 00:17:15.660
исправить данные, перезапустить процесс

00:17:15.660 --> 00:17:17.500
и проверить все последующие системы.

00:17:17.580 --> 00:17:19.340
Умножьте это на сотни триггеров в месяц,

00:17:19.520 --> 00:17:21.280
и внезапно ваш эффективный рабочий процесс

00:17:21.280 --> 00:17:23.100
без кода получит постоянного помощника.

00:17:23.320 --> 00:17:25.080
Запросы на информацию стоят секунды,

00:17:25.300 --> 00:17:26.220
исправление — дни.

00:17:26.380 --> 00:17:27.680
И все же люди сопротивляются.

00:17:27.900 --> 00:17:29.440
Они утверждают, что запросы на информацию

00:17:29.440 --> 00:17:31.020
замедляют инновации, создают препятствия

00:17:31.020 --> 00:17:32.600
или заставляют людей снова взаимодействовать.

00:17:32.760 --> 00:17:33.060
Верно?

00:17:33.220 --> 00:17:34.440
Да, и это великолепно.

00:17:34.600 --> 00:17:35.980
Игнорирование запросов на информацию —

00:17:35.980 --> 00:17:37.120
это как отстегнуть ремни безопасности,

00:17:37.120 --> 00:17:38.700
потому что вы предпочитаете свободу движения.

00:17:38.880 --> 00:17:40.820
Это оптимизм, замаскированный под халатность.

00:17:40.980 --> 00:17:42.280
Управление существует именно потому,

00:17:42.480 --> 00:17:43.380
что люди забывают детали,

00:17:43.580 --> 00:17:44.800
спешат с ответами и предполагают,

00:17:44.960 --> 00:17:46.020
что машины исправят это позже.

00:17:46.180 --> 00:17:47.660
Машины не чинят, это делают люди.

00:17:47.840 --> 00:17:48.760
И делают это мучительно,

00:17:48.940 --> 00:17:50.280
после того, как система ломается.

00:17:50.420 --> 00:17:52.700
Поэтому, если у вас возникнет соблазн пропустить RFI,

00:17:52.840 --> 00:17:54.500
представьте, что вы пишете отчет о соответствии

00:17:54.500 --> 00:17:56.080
за следующий квартал цветными карандашами,

00:17:56.180 --> 00:17:58.360
потому что происхождение ваших данных превратилось в догадки.

00:17:58.700 --> 00:18:00.020
Драматично, лишь отчасти.

00:18:00.200 --> 00:18:02.780
Без RFI ваша автоматизация не соответствует требованиям.

00:18:02.780 --> 00:18:04.560
Это творческое письмо с временными метками.

00:18:04.740 --> 00:18:06.160
Каждое пропущенное поле — это ложь,

00:18:06.220 --> 00:18:07.680
которую ваша система говорит сама себе,

00:18:07.820 --> 00:18:09.120
а каждая непроверенная запись —

00:18:09.120 --> 00:18:10.940
это нарушение политики, ожидающей обнаружения.

00:18:11.140 --> 00:18:14.360
Результатом включения RFI является не административный триумф,

00:18:14.400 --> 00:18:15.540
а операционная дисциплина.

00:18:15.660 --> 00:18:16.420
Как только вы увидите,

00:18:16.560 --> 00:18:18.940
насколько чистыми, последовательными и подающимися аудиту

00:18:18.940 --> 00:18:19.860
становятся ваши потоки,

00:18:20.020 --> 00:18:21.780
вы удивитесь, как вы вообще терпели этот хаос.

00:18:21.940 --> 00:18:25.260
RFI превращает автоматизацию из упражнения на доверие в систему контроля.

00:18:25.360 --> 00:18:27.260
Поэтому, если ваши потоки постоянно дают сбои,

00:18:27.380 --> 00:18:28.520
возможно, проблема не в капайлот,

00:18:28.520 --> 00:18:30.560
а в том, что вы позволяли своему программному обеспечению

00:18:30.560 --> 00:18:31.540
доверять людям без контроля.

00:18:31.660 --> 00:18:32.900
Это обновление системы управления,

00:18:33.020 --> 00:18:34.640
о необходимости которого вы даже не подозревали.

00:18:34.840 --> 00:18:37.280
Дело в том, что большинство людей в конечном итоге понимают,

00:18:37.420 --> 00:18:39.280
что надежность — это не столько более умный и,

00:18:39.440 --> 00:18:40.700
сколько более строгое управление.

00:18:40.940 --> 00:18:41.940
Запрос информации.

00:18:42.160 --> 00:18:44.240
Действие — это не просто дополнительная доработка,

00:18:44.380 --> 00:18:45.640
это структурная целостность.

00:18:45.780 --> 00:18:47.720
Это разница между тем, работает ли наша автоматизация,

00:18:47.860 --> 00:18:50.160
и тем, может ли наша автоматизация доказать свою работоспособность.

00:18:50.300 --> 00:18:53.000
Когда вы интегрируете запрос информации в свои потоки Капайлот Студия,

00:18:53.160 --> 00:18:54.780
вы создаете замкнутый цикл подотчетности.

00:18:54.780 --> 00:18:57.440
Каждое решение проверяется, каждое несоответствие устраняется,

00:18:57.640 --> 00:18:58.560
каждая запись защищается.

00:18:58.740 --> 00:19:00.420
В этом и заключается настоящая магия.

00:19:00.620 --> 00:19:02.800
Запрос информации не просто обеспечивает соблюдение правил,

00:19:02.960 --> 00:19:05.960
он преобразует абстрактное управление в ощутимое поведение рабочего процесса.

00:19:06.080 --> 00:19:09.120
Ваш и не просто доверяет тексту, он его перекрестно проверяет.

00:19:09.300 --> 00:19:12.700
Ваш поток не просто записывает данные, он требует обеспечения качества.

00:19:12.860 --> 00:19:14.960
Это управление — замаскированное подфункциональность,

00:19:15.140 --> 00:19:17.600
и именно поэтому оно незаметно революционизирует надежность.

00:19:17.760 --> 00:19:19.120
Представьте себе управление данными,

00:19:19.340 --> 00:19:22.160
соответствие требованиям и надежность как три стороны одного треугольника.

00:19:22.160 --> 00:19:25.920
Без запроса информации эта структура рушится, превращаясь в обходные пути и оправдания.

00:19:26.100 --> 00:19:28.720
С запросом информации каждая сторона поддерживает другую.

00:19:28.860 --> 00:19:30.920
Качество данных обеспечивает соответствие требованиям.

00:19:31.060 --> 00:19:34.580
Соответствие требованиям гарантирует очлеживаемость, а очлеживаемость повышает надежность.

00:19:34.720 --> 00:19:37.560
Вы прекращаете тушить пожары и начинаете проводить аудит с уверенностью.

00:19:37.660 --> 00:19:39.780
И да, ваши аудиторы действительно будут улыбаться.

00:19:39.920 --> 00:19:41.460
Тревожный, но измеримый результат.

00:19:41.720 --> 00:19:42.820
Итак, вот ваш вывод.

00:19:42.980 --> 00:19:45.180
Перестаньте относиться к управлению как к бюрократии.

00:19:45.320 --> 00:19:45.840
Это броня.

00:19:45.840 --> 00:19:50.460
Запросы на информацию RFI — это пластина, которая не позволяет вашим автоматизированным процессам насаживаться на некачественные данные.

00:19:50.600 --> 00:19:54.500
Если ваши рабочие процессы еще не внедрили это, вы не управляете процессом, а выживаете в условиях невезения.

00:19:54.620 --> 00:19:57.560
А поскольку невезение в конце концов заканчивается, укрепите свои потоки прямо сейчас.

00:19:57.760 --> 00:20:01.480
Добавьте запросы на информацию RFI в каждый процесс, где отсутствующие или сомнительные данные могут вызвать проблемы.

00:20:01.640 --> 00:20:03.600
Научите свой и проверять, а не предполагать.

00:20:03.740 --> 00:20:08.780
Относитесь к каждому ответу на запрос на информацию как к тому, чем он является на самом деле, как к подтверждению ответственности, заложенному в коде.

00:20:08.780 --> 00:20:13.060
Если это объяснение спасло вас от одного кошмара, связанного с качеством данных, отплатите ему тем же.

00:20:13.320 --> 00:20:13.800
Подпишитесь.

00:20:13.980 --> 00:20:19.580
Нажмите «Подписаться», включите уведомления и продолжайте создавать потоки Копайлот Студия, которые не просто работают, но и выдерживают аудит.

00:20:19.700 --> 00:20:21.400
Эффективность безнадежности — это хаос.

00:20:21.620 --> 00:20:23.380
Радиочастотные помехи делают его цивилизованным.
