I'm Tomás Herrera. Day job is backend and infrastructure at ArchyBase — mostly the path from an uploaded file to a finished artifact: validate, store, enqueue, and return a result the rest of the system is allowed to trust. This post is about a sibling product our team also builds, and specifically about a converter that turns a photo into a layout. I'm not going to talk about the vision model. That's a different layer, and a different person on the team. I'm talking about what the job is allowed to persist after a photo comes in.
The short version: a listing photo is a projection. The layout you get back is a draft estimated from what's visible in the frame. If your property record, your quote, or your inventory system files those numbers as a survey, you've promoted an estimate to a fact. I don't want that write to happen by accident.
The job is not “upload, then believe”
The product page is honest about the shape of the work, and I like that more than a magic demo. You upload a JPEG, PNG, or WebP (up to 10MB). You can add a short note about what the floor plan should look like. You pick a quality mode. You get a 2D technical plan back, as an image, and you can regenerate if the first pass misses a wall.
That last clause matters. “Regenerate if the first pass misses a wall” is not a flourish. It is an admission that a missed wall is a normal failure class, not a rare crash. A backend that treats the first successful blob as authoritative will happily store an open floor where a wall should have been.
So the durable unit of work, for me, looks closer to this than to a one-shot HTTP response:
Job {
job_id
input_ref // object key for the photo
input_kind // room_photo | house_interior | aerial
hint? // optional text, not a measured brief
quality_mode // fast | best (latency vs refinement; not a SLA)
state // queued | running | succeeded | failed
result_ref? // output image
error_class? // invalid_input | unreadable_photo | incomplete_layout | internal
confidence_policy // estimated_from_visible — never survey_grade
}
I made up the field names. They are not FloorAI internals. They're the checklist I want in front of any service that accepts a photo and emits a plan-shaped artifact.
Three input types are three failure classes
The page groups inputs as a room photo, a wider house interior, or an aerial / drone shot of a building. That's a product convenience. For a job queue, it's a classification problem, because the failure modes don't overlap cleanly.
A room photo usually gives you two or three walls, a floor plane, maybe a doorway, and a lot of furniture occluding the rest. The missing wall is often the one behind the camera. If you persist that result as a complete room, you've invented a fourth side from a viewpoint that never saw it.
A house interior — a wider shot, a listing gallery image, a scanned print — can show circulation and room boundaries, but only the ones in view. A corridor that turns out of frame will not appear because the model is “careful.” It will not appear because it was never in the pixels. Old or low-quality photos can still convert, which is useful for digitizing a record when no drawing exists. Useful is not the same as complete.
An aerial or drone shot is a different object. The page is explicit: you can scan a footprint when you can't walk the building room by room. A footprint is not a room schedule. If a downstream form labels the output “3-bed, 2-bath” because a listing caption said so, that's a caption write, not a measurement write. Keep those sources apart.
I would rather the API require an input_kind (or infer it and show the inference) than silently mix these into one “image-to-plan” success state. The client can then branch: a missed interior wall is “try another photo or regenerate”; an aerial result is “this is a footprint, don't ask it for closet widths.”
Reject early, estimate later
Upload validation should be boring and strict:
- Reject empty files, wrong MIME types, and anything over the published 10MB cap before a worker starts.
- Decode enough to know you have an actual image, not a renamed PDF.
- Don't invent a dimension unit in preprocess just because a later renderer likes meters.
The estimate happens after that, from visible structure in the shot — walls, doorways, room boundaries the photo actually contains. The page says this directly: no tape measure is required, and dimensions are estimated from what's visible rather than from measurements you typed in. That's the product promise, and it should also be the persistence promise.
What I will not do is this:
- Accept a phone photo.
- Get a layout image with some numbers on it.
- OCR or hardcode those numbers into
wall.length_m. - Mark the unit as surveyed.
If you need a field, call it what it is: estimated_from_photo, with the source image id and the job id. A later measured drawing can replace it. A later photo can revise it. Neither should look identical to a laser-measured wall in the database.
Failures the user can act on
I care about error classes the client can branch on, not a generic “something went wrong.” A reasonable set for this product shape:
| Class | What happened | What the user can do |
|---|---|---|
invalid_input |
bad type, empty file, over 10MB | fix the file |
unreadable_photo |
decode failed, or the frame has no usable structure | try a wider / sharper shot |
incomplete_layout |
job succeeded, but a wall or room boundary is obviously missing | regenerate, or upload a shot that includes the missing side |
wrong_kind |
an aerial footprint was treated like an interior, or the reverse | relabel the input and run again |
internal |
worker / storage blip | retry the same job or attempt |
incomplete_layout is the interesting one, because it may still return an image. That's a succeeded job with a warning, or a soft failure, depending on how strict you want to be. I prefer “succeeded, with an explicit warning the first pass may have missed a wall” over a silent 200 and a floor plan that walks through a load-bearing line. The product already tells people to regenerate. The API should make that path first-class, not a folksy tip buried under a download button.
Don't auto-retry invalid_input or “I can't see a room in this picture.” That wastes worker time and trains the UI to spin. Auto-retry only the infra blips, and only with an idempotency key so you don't persist two final images for one photo.
What the output is allowed to be
The download is an image, ready to share or use as a starting reference. Starting reference is the right phrase. It is not a CAD handoff, and I have not claimed it exports a measured drawing. If someone on the team later adds a dimensioned file type, that still wouldn't make a phone photo into a survey. It would make the estimate easier to open in other tools — which is useful, and still an estimate.
The optional text field — “describe what the floor plan should look like” — is a hint, not a substitute for the hidden wall. If the photo doesn't show a second bedroom, a hint that says “two bedrooms” is a request, not evidence. I'd keep that hint on the job record so a reviewer can see what was asked, and I would not let it silently overwrite geometry that isn't in the image.
Quality modes (faster output vs more refinement) are a latency and compute trade-off. I'm not going to invent how many seconds either mode takes. The only rule I want is: both modes still write estimated_from_visible. A “best” result is not a license to drop the qualifier.
A short checklist before anyone files the result
This is the list I want next to the download button, or next to whatever internal tool first persists the artifact:
- Record the source photo and the job id with the layout. No orphan plans.
- Label the input kind: room, interior, or aerial / footprint.
- Treat every length as estimated from the visible frame, never as surveyed, until a real measurement replaces it.
- If a wall is missing, regenerate or shoot the missing side. Don't close the loop in the database by hand and call it the same job.
- Don't copy listing-caption room counts into the plan record just because the caption was on the same page as the photo.
- Let a later measured plan supersede the estimate without deleting the photo job — you want the history.
I use this converter when there is no drawing on file and a photo is all you have. That's a real situation: old units, incomplete listing packs, a job site with no blueprint in the email thread. A draft layout from a photo is much better than a blank. It is not better than a survey, and it should never be stored as if it were one.
The unpaid work, on the backend, is making that distinction boring and visible. If the only success state you have is “image arrived,” you will eventually file photo-derived meters as a survey. I'd rather fail that write on purpose.


Top comments (0)