Coder Legion - Recent posts tagged app

🛡️ Mulher Amparada | Personalização, Discrição e Camadas de Autenticação

Fri, 30 Oct 2026 16:01:24 +0000

O Mulher Amparada conta com recursos de personalização visual, discrição e proteção de acesso, integrados para proporcionar uma experiência diferenciada às usuárias.

🎨 Ícone Monocromático e Integração com Material You

O aplicativo oferece suporte aos ícones temáticos do Android (Themed Icons), permitindo que seu ícone acompanhe a identidade visual configurada no dispositivo.

Máscara monocromática: disponibiliza uma versão específica do ícone para utilização pelo sistema Android. Paleta dinâmica: permite que o Android adapte a aparência do ícone às cores escolhidas pela usuária. Integração visual: acompanha a personalização da tela inicial, proporcionando maior consistência com a interface do sistema.

Assim, o ícone não fica limitado às suas cores originais: ele pode assumir a identidade cromática definida pelo próprio Android, sem exigir versões manuais para cada combinação de cores.

🩺 Disfarce do aplicativo: Assistente de Saúde

O Mulher Amparada possui um mecanismo de disfarce visual que apresenta o aplicativo inicialmente como um assistente de saúde genérico.

É apresentada a WelcomeActivity, com uma tela de boas-vindas identificada como Assistente UI 33. O estado da primeira abertura é armazenado por meio da classe Cripto.

⚠️ Importante: os indicadores apresentados na interface de saúde são fictícios e não representam medições, avaliações ou informações médicas reais.

🧮 Segundo disfarce: Calculadora

O aplicativo também disponibiliza uma interface de calculadora, acessível pelo ícone localizado no canto superior direito da tela do assistente de saúde.

Essa interface possui uma funcionalidade adicional de recuperação de acesso, protegida pelo BiometricPrompt.

Caso a usuária esqueça suas credenciais, poderá utilizar a autenticação pelas credenciais do próprio dispositivo para iniciar o procedimento de redefinição.

Após a validação, o sistema solicita as informações de recuperação e a senha, conforme o fluxo implementado.

🔐 Três mecanismos de autenticação e recuperação

O sistema possui três fluxos distintos:

Autenticação pela senha do teclado

A usuária informa sua senha. A interface passa para uma apresentação completamente preta ou branca, conforme o modo de exibição do dispositivo. Cinco toques na tela permitem retornar à interface normal e prosseguir para a HubActivity.

Recuperação pelo toque no visor

A usuária realiza cinco toques na tela em menos de dois segundos para iniciar o procedimento de redefinição. Informa a pergunta de recuperação. Após a validação, a interface passa para a tela preta ou branca. Realiza mais cinco toques. Informa sua nova senha para concluir a redefinição.

Recuperação pelo BiometricPrompt

A usuária acessa a opção de recuperação na interface de calculadora. O sistema solicita a autenticação pelas credenciais do dispositivo (Device Credential). Após a validação, é iniciado o procedimento de redefinição. A usuária confirma as informações solicitadas e passa pela etapa de tela preta ou branca, com cinco toques. Por fim, cadastra uma nova senha e uma nova pergunta de recuperação. 🔒 Cadastro e armazenamento das credenciais

Na configuração inicial, a usuária precisa realizar cinco toques no visor para iniciar o cadastro da senha e da pergunta de recuperação.

As informações são processadas e armazenadas por meio da classe Kotlin Cripto, responsável pelas operações de proteção e gerenciamento dessas credenciais.

O sistema também permite redefinir as informações posteriormente, utilizando os mecanismos de recuperação disponíveis.

💜 Uma experiência construída em camadas

O Mulher Amparada combina:

Personalização visual com Material You. Suporte a ícones temáticos do Android. Interface de assistente de saúde como primeiro disfarce. Interface de calculadora como segundo disfarce. Autenticação biométrica e credenciais do dispositivo. Senha personalizada e pergunta de recuperação. Procedimentos distintos para redefinição de credenciais. Gerenciamento criptográfico das informações de acesso.

Mulher Amparada — tecnologia, discrição e proteção reunidas em uma única experiência. 🛡️

Two projects, one motivation

Sun, 12 Jul 2026 22:22:00 +0000

Recently, I built two projects, just because I wanted to give people the info they need: news.

Dinkus was the first one. It is a MacOS RSS feed aggregator, and it gives updates—not only for news—but also for other website updates. It is particularly interesting because it appears on the system tray—which I thought was quite unique, until I figured out there were many other instances of this.

Unsatisfied, I came up with The Olden Gazette, a novel news aggregator that pulls from BBC RSS, the NewsData API, and many other sources. It provides weather, breaking news, articles and the date. It is all black-and-white, and it is vintage, which is the point. Less screamy, loud and cramped, more real news.

These two projects taught me how to better use many frameworks, especially Rumps and Flask, and they really improved my coding style: in The Olden Gazette, I began splitting the project into files, which I didn't really do previously. This may seem silly, because no one doesn't split the code, but I learned this. Late.

That's really it... I hope these tools are nice little gems.

The Development Roadmap for Launching an AI Companion App Like Candy AI

Thu, 09 Jul 2026 08:48:10 +0000

The fast-growing AI-based companion platforms have led to the emergence of an entirely new class of digital products focused on the emotional aspect of communication, its continuity, and personalization. Applications created based on the example of services such as Candy AI are becoming less associated with simple chatbot functionality and are being implemented as full-fledged interactive experiences with elements of conversations, memorization, personalization, and real-time interactions. The successful creation of an application in this space for business organizations calls for not only implementation of the user interface and language model but also the presence of a clear product roadmap, technology choices, safety plans, and knowledge of user interaction patterns with companion AI. That is why AI Companion app development is gaining momentum as a distinct product niche.

If the company is considering a product like the Candy AI Clone, or even designing a unique AI-based companion that will be comparable to other platforms out there, the success of their product will be contingent upon making it feel adaptive, responsive, and technically sound. An effective road map will help companies navigate the process of going from concept to launch.

Step 1: Define the Product Vision and User Use Case

The first stage in AI Companion app development is clarifying what type of relationship the app is meant to create with users. Not all companion apps serve the same purpose. Some focus on casual conversation and entertainment, while others emphasize emotional support, virtual relationship simulation, lifestyle guidance, or character-based interaction. Before development begins, businesses need to identify the app’s core use case, target audience, tone of interaction, and monetization direction.

This step is particularly important when developing a Candy AI Clone-style platform, because simply replicating a surface-level feature set is rarely enough. The product needs a clear identity of its own. That means deciding whether the experience will revolve around romantic companionship, friendship simulation, gamified interaction, or premium personalized conversation. These early decisions shape everything from the app’s personality system to its content boundaries and subscription strategy.

Step 2: Design the Companion Experience, Not Just the Interface

The next step is to design how the AI companion behaves, communicates, and evolves over time. Companion apps succeed when the experience feels emotionally consistent and engaging rather than transactional. That requires careful planning around personality design, memory logic, conversation flow, emotional tone, and user interaction patterns.

In practical terms, businesses need to define how the AI introduces itself, remembers user details, handles follow-up conversations, responds to emotional cues, and maintains a distinct persona. This is one of the biggest differences between a standard chatbot and a companion platform. In AI Companion app development, the goal is not only to answer prompts but to create a sense of continuity and familiarity across repeated interactions. A Candy AI Clone-inspired app often depends heavily on this relationship layer, which is why conversation design and personality modeling should be treated as core product features rather than cosmetic enhancements.

Step 3: Build the AI Architecture Around Memory and Personalization

A next-generation companion app needs a technical foundation that supports adaptive, persistent interaction. The language model is only one part of that system. To deliver a more human-like experience, businesses must also invest in memory management, personalization logic, retrieval mechanisms, and moderation layers.

Memory allows the app to recall names, preferences, recurring topics, and interaction history. Personalization enables the AI to adjust tone, suggestions, and responses based on user behavior over time. Together, these systems make the companion feel more intelligent and emotionally relevant. For a Candy AI Clone concept, this layer is especially important because users expect the app to respond with familiarity and continuity rather than generic answers.

At the infrastructure level, AI Companion app development may involve LLM orchestration, vector databases for memory retrieval, recommendation systems, speech modules, image generation capabilities, and backend services that manage sessions, preferences, and user-generated content. The right architecture should be modular enough to evolve as the product grows and user expectations change.

Step 4: Integrate Multimodal Features for a More Immersive Experience

Modern companion apps are increasingly moving beyond text-only interaction. Voice responses, avatar systems, visual customization, image generation, and expressive UI elements are becoming part of the expected experience. Businesses entering this space should think carefully about which multimodal features align with their audience and product strategy.

For example, a Candy AI Clone-style app may include avatar selection, voice-enabled chat, image sharing, character customization, or AI-generated visual interactions. These features can strengthen immersion and improve retention when implemented thoughtfully. However, they also increase complexity in terms of content safety, infrastructure cost, and user experience design. In AI Companion app development, multimodal features should support the emotional and conversational goals of the platform rather than being added only for novelty.

Step 5: Build Safety, Privacy, and Content Governance into the Product

AI companion apps operate in a highly personal and emotionally sensitive environment, which makes safety and privacy essential from the earliest stages of development. Businesses cannot treat moderation or policy controls as a final-stage addition. Instead, they need to embed safeguards directly into the platform architecture and interaction design.

This includes content moderation rules, age verification where appropriate, privacy controls for stored memories, transparent consent around data usage, and boundaries around emotionally sensitive conversations. If the platform allows image generation, voice interaction, or adult-oriented themes, the safety layer becomes even more critical. Businesses exploring a Candy AI Clone concept should pay special attention to how the platform manages user expectations, relationship simulation, emotional dependency, and responsible communication boundaries.

In AI Companion app development, trust is a long-term product advantage. Users are more likely to stay engaged with a platform when they feel their data is protected, the AI behaves predictably, and the interaction remains within clearly defined boundaries.

Step 6: Develop a Scalable Monetization and Engagement Strategy

Launching the app is only one part of the roadmap. Businesses also need a sustainable growth and monetization strategy that fits the behavior of companion AI users. Common revenue models in this category include subscription plans, premium message tiers, voice access, avatar customization, exclusive personalities, virtual gifting, and advanced memory or personalization features.

A platform inspired by the Candy AI Clone model often depends on premium engagement features rather than one-time transactions. That means the app should be designed with retention loops in mind, including daily interaction incentives, evolving companion relationships, personalized recommendations, and optional upgrades that enhance the user experience without making the free experience unusable. In AI Companion app development, monetization should feel integrated into the emotional and conversational value of the product rather than forced on top of it.

Step 7: Launch, Measure, and Continuously Refine the Experience

Once the product is launched, the roadmap shifts from development to iteration. AI companion apps require continuous refinement because user expectations, engagement patterns, and safety challenges evolve quickly. Businesses need to monitor conversation quality, retention behavior, feature usage, monetization performance, and moderation outcomes in order to improve the platform over time.

This post-launch phase is where analytics becomes especially important. Businesses should track which companion traits users respond to, where conversations lose momentum, what premium features drive retention, and which safety triggers require adjustment. A Candy AI Clone-style product cannot remain static if it wants to stay competitive. The strongest platforms treat launch as the beginning of a longer product evolution process driven by data, user behavior, and ongoing AI optimization.

Conclusion

To begin creating a complementary product based on the principles of Candy AI demands much more than simply building a personality-laden chatbot. To be able to do so, one needs to come up with the user scenario, create consistent emotionally rich interactions, develop the mechanisms of memory and personalization, add multimodality to the process, and design in safety from the very start. The development of an AI Companion app is turning into a complex field that combines several areas of expertise.

In case of those businesses seeking to develop a Candy AI Clone, the true potential does not lie in developing a copy of an existing platform but in comprehending why companion AI is so appealing. Having the right roadmap will allow them to leverage this knowledge to develop a viable digital solution with engagement, trust, and business value potential. Given that the future success of companion apps depends on factors like emotional continuity and safety of the user, such businesses are the most likely to create the next era of AI relationships.

Shopify Speed Optimization: Core Web Vitals Guide for E-Commerce

Fri, 03 Jul 2026 21:42:57 +0000

Shopify speed optimization is not the same problem as speeding up a marketing brochure site. Your theme renders product grids, variant pickers, and cart drawers; your app stack injects reviews, personalisation, and chat on top of Liquid templates you may not fully control. Core Web Vitals still measure the outcome shoppers feel: LCP when the product image or hero appears, INP when taps on size or colour respond, CLS when a banner or widget shoves the add-to-cart button mid-click.

What follows is a practical Shopify playbook aligned to those metrics: which URLs to optimise first, what typically breaks each vital on Online Store 2.0 themes, and how scheduled lab monitoring plus field data fits once fixes ship. For metric definitions and funnel-wide priorities, start with What Are Core Web Vitals? and Performance Monitoring for E-Commerce: What Metrics Matter Most; here the focus stays on Shopify implementation choices.

Which Shopify URLs matter most for Core Web Vitals

Sitewide averages hide the pages that carry revenue. On most Shopify stores, prioritise lab and field coverage in this order:

Product detail pages (PDPs): largest media, variant interactions, review widgets; strongest link to add-to-basket progression in published retail speed research summarised on web.dev.
Collection and search results: many thumbnails, filter and sort UI; INP and CLS risks as rows load.
Cart and cart drawer: coupons, upsells, persistence scripts; interaction-heavy even when LCP looks fine.
Checkout: Shopify-hosted checkout limits how much theme code you can change, but payment and form responsiveness still matter for INP; monitor the URLs you can test and treat checkout regressions as release incidents.
Home and campaign landers: heavy heroes and promotional sections; important for acquisition, but do not let them crowd out PDP and cart in your test list.

Agencies should document this list per client in the onboarding file. A store that only monitors the homepage will miss the PDP regression that shows up in support tickets first.

LCP on Shopify: images, heroes, and product media

Largest Contentful Paint on Shopify is usually an image problem before it is a server problem. Shopify serves storefront assets through its CDN; the win is sending the right width, format, and priority, not bypassing the platform.

Theme and section hygiene

Audit Online Store 2.0 sections on the homepage and PDP templates. Duplicate hero sliders, autoplaying video heroes, and oversized background images are common LCP offenders. Remove sections you are not using; each active section can add CSS and JavaScript even when it looks empty on mobile.

Use Shopify’s image APIs and theme settings that output responsive srcset and explicit width parameters rather than uploading 4000px masters into a 600px slot. Our image optimisation strategies for better LCP applies directly to product galleries and collection grids.

Product media

On PDPs, the first visible gallery image is often the LCP element. Preload only when you have measured that element in Lighthouse or PageSpeed Insights; blind preloading every variant image wastes bandwidth. For video or 3D media, defer non-critical players until after the primary image paints.

Fonts and render blocking

Custom fonts from theme settings or apps can delay text and push LCP to a late paint. Subset fonts where possible, limit weight variants, and use font-display: swap in theme CSS when you control the declaration. Font subsetting guidance in our font subsetting how-to is relevant when merchants self-host display faces outside Shopify’s defaults.

INP on Shopify: variants, filters, and app JavaScript

Interaction to Next Paint reflects how quickly the page responds after a shopper taps. Shopify themes and apps add listeners on variant radios, colour swatches, collection filters, cart drawers, and sticky headers. Long main-thread tasks from analytics or personalisation often show up here before they move LCP.

Variant pickers and quick-add

Test INP on PDP with throttled mobile profiles. If changing size stalls the UI, profile with Chrome DevTools performance recordings and look for synchronous work in theme JavaScript or app embeds tied to inventory updates. Split heavy work across frames or load non-critical features after the selection state updates.

Collection filters and sort

Faceted navigation triggers DOM updates and sometimes refetches. Filters that re-render large product grids on every click are a common INP regression after merchandising changes. Prefer incremental updates and skeleton states that do not block the next input.

Cart drawer and mini-cart

Opening the cart drawer often loads recommendations or loyalty modules. Defer those requests until after the drawer animation completes if your theme allows it. INP on “add to cart” is a better alert threshold than homepage LCP for many Shopify retainers.

For a general method to rank script cost, use Third-Party Scripts and Performance: How to Identify and Fix the Worst Offenders; on Shopify, the offenders are usually apps rather than hand-pasted tags.

CLS on Shopify: apps, embeds, and dynamic inserts

Cumulative Layout Shift punishes layout movement without reserved space. Shopify stores see CLS from review star widgets, consent banners, promo bars, lazy-loaded images without dimensions, and recommendation carousels that mount late.

Reserve height for embed containers in theme Liquid where you can. For app blocks you cannot edit, ask the vendor for a fixed-aspect placeholder or load the block below the fold on mobile. Compare CLS on long collection pages with infinite scroll; each appended row is a shift risk if image heights are unknown.

Sticky headers and announcement bars compete for the same viewport. If marketing enables both, measure CLS on PDP and checkout paths, not only the homepage.

Shopify apps: audit, defer, and remove

Apps are the fastest way to undo theme work. Each installed app can inject JavaScript through theme app extensions, ScriptTag legacy patterns, or checkout UI extensions. Merchants often add apps for reviews, search, subscriptions, and upsells without a performance review.

Run a quarterly app audit:

List every installed app and which templates it touches.
Disable suspect apps on a duplicate theme or staging preview and re-run PageSpeed Insights on PDP and collection URLs.
Remove apps that duplicate native Shopify features you already pay for.
Gate new apps with a before-and-after lab run stored in your monitoring history.

Shopify’s own performance team publishes aggregated theme and vitals context on the Shopify performance blog; use it for platform-level baselines, then prove your store’s numbers with your URL list.

Theme choices without a full rebuild

You do not always need a new theme to improve Shopify speed. Before a migration project, try:

Disabling unused sections and app blocks on high-traffic templates.
Replacing carousel heroes with a single optimised image on mobile.
Moving non-critical scripts to defer or loading them on interaction when theme architecture allows.
Aligning image aspect ratios in collection cards so the grid does not reflow as images arrive.

When a rebuild is justified, favour lean Online Store 2.0 themes with minimal JavaScript on PDP and collection templates, and verify demo store scores on mobile, not desktop-only marketing screenshots.

Set performance budgets for Shopify templates

Speed work sticks when thresholds are written down. Use separate mobile and desktop budgets per site in your monitoring tool, with tighter bands on PDP and cart than on policy pages. The performance budget thresholds template includes ecommerce-friendly starting values; mark them provisional for the first month while apps and seasonal campaigns settle.

Example emphasis for Shopify:

Template	Metrics to weight	Notes
PDP	LCP, INP, CLS	Gallery, variants, reviews
Collection	LCP, INP	Filters, many thumbnails
Cart / drawer	INP, CLS	Upsells, coupons
Home	LCP, CLS	Hero, promo sections

Pair budgets with email or digest alerts so a theme deploy or app update triggers investigation before CrUX reflects the regression weeks later.

Monitor Shopify stores with scheduled PageSpeed tests

Synthetic lab runs through PageSpeed Insights give repeatable before-and-after proof when you change a theme or remove an app. Schedule mobile and desktop tests on the URL set above, with higher frequency during sale periods. How to schedule test frequency and priority across your portfolio covers cadence when you manage multiple merchant sites.

Apogee Watcher is built for that portfolio pattern: one organisation, a site per client store, discovery from sitemaps where Shopify exposes them, and budgets on the templates you list. We do not replace Shopify’s admin analytics; we give agencies a shared history and alert layer without a separate API key per merchant. Setup steps live in Getting Started with Apogee Watcher: A Step-by-Step Setup Guide.

Read CrUX percentiles beside lab scores when Google publishes field data for a URL. Field data answers what shoppers saw; lab data answers what changed after last night’s deploy. Both belong in client reports; neither alone is enough for Shopify where apps change weekly.

Shopify speed optimization checklist

Use this as a release gate before peak season or after a major app install:

Mobile and desktop lab runs on homepage, top collection, top three PDPs, and cart path.
LCP element identified on PDP; image dimensions and priority verified.
INP spot-check on variant change, filter toggle, and add to cart.
CLS check with promo bar and consent banner enabled as in production.
App inventory reviewed; unused apps removed.
Budgets set per template; alert recipient confirmed.
Baseline note stored with owner and three follow-up actions.

Agencies can mirror the same checklist across clients with the Core Web Vitals monitoring checklist for agencies.

FAQ

What is a good LCP for a Shopify store?

Google’s public guidance treats LCP at or below 2.5 seconds at the 75th percentile as good in field data. Lab targets can be stricter on PDP during optimisation sprints. Compare mobile separately; Shopify traffic skews mobile for many merchants.

Why is my Shopify PageSpeed score different from CrUX?

Lab tests use simulated conditions on a single run; CrUX aggregates real Chrome users over a rolling window. Apps, traffic mix, and geography differ. Use lab for regressions after deploys; use CrUX for whether shoppers broadly experience the vitals band you promise.

Do Shopify apps always hurt Core Web Vitals?

Not always, but unmanaged apps are the most common regression source we see on merchant stores. Audit before install and measure after.

Can I optimise Shopify checkout theme code?

Checkout is largely platform-hosted. Focus on cart, accelerated checkout buttons, and any scripts that run before checkout handoff. Monitor checkout URLs where tests are permitted and treat payment-step INP issues as vendor or platform support cases when you cannot edit the template.

How is Shopify speed optimization different from WooCommerce?

Metrics are the same; implementation differs. Shopify centralises theme and app embed patterns; WooCommerce often mixes plugins and hosting. Optimise and monitor per platform, not with one generic plugin list.

Should agencies monitor every Shopify URL?

No. Start with ten to twenty priority URLs per store, emphasising PDP, collections that drive revenue, and cart. Expand when alert triage stays manageable.

Does improving Core Web Vitals increase Shopify conversion?

Published retail studies link small speed gains to measurable funnel effects; exact uplift depends on baseline speed and traffic. Use monitoring to prove before-and-after on your client’s templates rather than citing industry averages alone.

Shopify speed optimization that lasts pairs template-level fixes with a short URL list, explicit budgets, and scheduled tests that survive the next app install. Fix PDP and cart first, audit apps quarterly, and keep mobile lab runs in the same rhythm as theme releases.

Start a free Apogee Watcher account to schedule mobile and desktop tests with vitals budgets on Shopify client sites, or run a free domain PageSpeed check on a storefront before you scope the first optimisation sprint.

Your Photos Are Telling Strangers Where You Live: A Developer's Guide to EXIF and Privacy

Tue, 23 Jun 2026 07:13:01 +0000

Every JPEG your phone or camera produces ships with a hidden passenger: EXIF metadata. Most people never look at it. Most developers never strip it. And that gap has leaked everything from celebrities' home addresses to the exact location of an active-duty soldier's base.

If you build anything that touches user-uploaded images — a marketplace, a social app, a photo gallery — this is one of those quiet responsibilities that's easy to ignore until it's a headline. Here's what's actually in that metadata, how to read it, and how to strip it in a few lines of code.

What's hiding in a photo

EXIF (Exchangeable Image File Format) is a block of key–value data embedded in the file itself. A typical photo carries:

GPS coordinates — latitude, longitude, sometimes altitude. Precise enough to drop a pin on your front door.
Timestamps — when the shot was taken, down to the second.
Camera & lens — make, model, and often the camera body's serial number.
Settings — ISO, aperture, shutter speed, focal length.
Software — what edited the file and when.

Individually, harmless. Together, they're a movement log. Geotagged photos posted over time draw a map of where you live, work, sleep, and travel — and the timestamps tell anyone when you're not home.

Reading EXIF (so you can see the problem)

Python (Pillow)

from PIL import Image
from PIL.ExifTags import TAGS, GPSTAGS

img = Image.open("photo.jpg")
exif = img.getexif()

for tag_id, value in exif.items():
    tag = TAGS.get(tag_id, tag_id)
    print(f"{tag:25}: {value}")

# GPS lives in its own sub-block (IFD)
gps_ifd = exif.get_ifd(0x8825)  # GPSInfo
for key, val in gps_ifd.items():
    print(f"{GPSTAGS.get(key, key):25}: {val}")

Turning the raw GPS tuples into decimal degrees:

def to_decimal(dms, ref):
    degrees, minutes, seconds = [float(x) for x in dms]
    dec = degrees + minutes / 60 + seconds / 3600
    return -dec if ref in ("S", "W") else dec

lat = to_decimal(gps_ifd[2], gps_ifd[1])   # GPSLatitude, GPSLatitudeRef
lon = to_decimal(gps_ifd[4], gps_ifd[3])   # GPSLongitude, GPSLongitudeRef
print(f"https://maps.google.com/?q={lat},{lon}")

Run that on a geotagged photo and you'll get a clickable map link straight to wherever it was taken. That's the whole point — it's that easy for anyone else, too.

JavaScript (browser, with `exifr`)

import exifr from 'exifr';

// Read just the GPS — works on a File from an <input>
const gps = await exifr.gps(file);
console.log(gps?.latitude, gps?.longitude);

// Or pull everything
const data = await exifr.parse(file);
console.log(data.Make, data.Model, data.DateTimeOriginal);

Command line (ExifTool)

exiftool photo.jpg            # dump everything
exiftool -gps:all photo.jpg   # just the location data

Stripping EXIF (so you stop being the problem)

One-off, CLI

# ExifTool — removes all metadata
exiftool -all= photo.jpg

# ImageMagick — re-encode without metadata
convert photo.jpg -strip clean.jpg

Python

# piexif: surgical removal, keeps the pixels untouched
import piexif
piexif.remove("photo.jpg", "clean.jpg")

# Pillow: re-save without the exif kwarg
from PIL import Image
img = Image.open("photo.jpg")
img.save("clean.jpg")  # no exif= passed → metadata dropped

Server-side on upload (Node, `sharp`)

This is the one that matters in production. Strip metadata as part of your upload pipeline, automatically, for every image. Don't trust users to do it.

import sharp from 'sharp';

await sharp(inputBuffer)
  .rotate()            // bake in EXIF orientation BEFORE you drop it
  .jpeg({ quality: 82 })
  .toFile('clean.jpg'); // sharp strips metadata by default

⚠️ Gotcha: EXIF has an Orientation tag that tells viewers to rotate the image. If you strip metadata without applying that rotation first, photos that looked fine suddenly appear sideways. Always auto-orient (sharp's .rotate() with no args) before discarding metadata.

Client-side, before it ever uploads

Drawing an image onto a <canvas> and re-exporting it discards EXIF as a side effect:

function stripExif(file) {
  return new Promise((resolve) => {
    const img = new Image();
    img.onload = () => {
      const canvas = document.createElement('canvas');
      canvas.width = img.naturalWidth;
      canvas.height = img.naturalHeight;
      canvas.getContext('2d').drawImage(img, 0, 0);
      canvas.toBlob(resolve, 'image/jpeg', 0.9);
    };
    img.src = URL.createObjectURL(file);
  });
}

(Same orientation caveat applies — handle rotation before you rely on this.)

"Doesn't the platform strip it for me?"

Sometimes. Most large social networks strip EXIF on upload — but the behavior is inconsistent and changes without notice. Direct file delivery (email attachments, cloud links, raw downloads, messaging apps that send "as file") frequently keeps everything intact. The safe assumption: if you didn't strip it, it's still there.

There's a real trade-off, too. Photographers and archivists often want metadata — copyright, camera settings, capture time. So the right rule isn't "always nuke it," it's be deliberate: strip location and serial numbers from anything public-facing, and keep the rest only where it's genuinely useful and the user consents.

Where this shows up in the real world

When you run an image-heavy product, metadata handling stops being a curiosity and becomes part of your duty of care. At Fotio, where the whole business is delivering professional photo galleries from shoots across Spain, this is exactly the kind of detail that separates a polished pipeline from a leaky one — high-resolution images that look great, without quietly broadcasting a client's GPS trail. If you're curious how an image-first product is put together end to end, you can poke around at fotio.app.

The one-line takeaway

Treat EXIF like any other untrusted, potentially sensitive payload: inspect it, strip what's risky, and never assume someone else already handled it.

Add a metadata-stripping step to your upload pipeline today. It's a handful of lines, and it closes a privacy hole most apps don't even know they have.

Do you strip EXIF in your projects — client-side, server-side, or not at all? And have you ever found something alarming in a photo's metadata? Share it in the comments.

Accounts Aren't the End, Data is the Key: Lessons from the Cathay Pacific Incident

Tue, 26 Aug 2025 03:53:28 +0000

Cathay Pacific's "Miles Stolen" Raises Another Alarm

Recently, Cathay Pacific confirmed that approximately 1,000 accounts were illegally logged into, resulting in the theft of miles and unauthorized access to some personal information. The attackers exploited leaked account credentials and a two-factor authentication vulnerability. Although the vulnerability has been urgently patched, the incident highlights a reality: once authentication mechanisms are bypassed, the "trust defenses" of a company's data systems can collapse instantly.

The real hidden danger for companies goes beyond account theft.

For internal systems, accounts are merely entry points. The real risks lie in:

Can a compromised employee account gain access to multiple sensitive systems?

Are downloaded files still under control?

Are operations after authentication audited and tracked?

In other words, it's often not the login itself that's out of control, but whether the use of data after authentication remains under the company's control.

Thinking from "Authentication" to "Full Control"

Many companies focus their security efforts on "who can log in." However, once an attacker obtains legitimate identity, they can often freely manipulate, download, and distribute sensitive data within the system.

Therefore, enterprises need to expand their security perimeter beyond "authentication" to encompass the entire data lifecycle. This means:

Minimizing access rights: Only necessary personnel and devices are
allowed to access sensitive data;

Controllable operations: Imposing policy restrictions on sensitive
operations such as save, copy, and screenshots;

Full-process traceability: Recording and auditing the entire data
usage process to ensure risk traceability.

The Cathay Pacific incident reminds us that enterprises must not only guard against risks at the moment of "login," but also pay attention to every instance of "uncontrolled" data use after an account is bypassed. True security goes beyond preventing external intrusions and requires continuous internal control over every piece of data.

Several solutions have emerged on the market that address "full-lifecycle data control" and can help enterprises maintain control over sensitive information even after authentication. These solutions are worth considering and learning from.