Android Engineer at Square (Block): Cash App, Workflow, and a Heavy OSS Bench

Android engineer at Square (Block) in 2026

If you write Android for a living and have not used a library that came out of Square, your project is unusual. Retrofit, OkHttp, Moshi, Picasso, LeakCanary, Dagger (originally), ButterKnife (now retired in favor of view binding), and the Kotlin Workflow framework all originated at Square. The result is that Android engineers at Block work on the same primitives the rest of the industry imports, which gives the team unusual leverage on the platform itself.

The two big surfaces are Cash App and Square Point of Sale. Cash App is a consumer money app with peer-to-peer payments, a debit card, stock and bitcoin trading, tax filing, and a savings product, all in a single Android binary that ships to tens of millions of monthly active users. Square Point of Sale is the seller-facing app that runs on Square's own hardware (Square Register, Square Terminal) and on third-party Android tablets and phones, taking card-present payments and managing inventory, employees, and reporting.

Beyond the two flagships, Block also owns Tidal (music streaming) and Spiral (Bitcoin engineering), each of which has its own Android footprint, and the Cash App Pay SDK that merchants embed in their own apps. Block Inc. trades on NYSE under the ticker SQ; the company IPO'd as Square in November 2015 and renamed itself Block in December 2021 to reflect a broader scope beyond the original Square seller business.

The most visible engineer on the Android team is Jake Wharton, who joined Square in 2013 and has been a public face for both the company's open source program and Android's wider Kotlin migration. His personal site (jakewharton.com) and his GitHub remain among the best low-friction signals for the bar Square sets internally: terse Kotlin, careful APIs, and a strong preference for libraries that do one thing without surprises.

Interview process

Block runs separate Android loops for Cash App and for Square (the seller side), but the structure is similar. A typical Android engineer loop runs five to six rounds across recruiter screen, technical phone screen, and an onsite of three to four interviews:

• Recruiter screen: motivation, ladder fit, location and remote-eligibility, and a comp range. Block hires across San Francisco, New York, Atlanta, Toronto, Melbourne, Dublin, and several remote-eligible US states.
• Technical phone screen: a coding problem in Kotlin or Java, frequently with an Android flavor (parsing, threading, lifecycle), or a focused Android API question.
• Onsite coding: one or two rounds; expect at least one to be explicitly Android: build a small feature, wire up a network call, handle a configuration change, or refactor a sample screen toward a clean architecture.
• System or app design: design the offline cache, the sync engine, or the navigation graph for a feature like a transaction list or a checkout flow. Expect deep follow-ups on threading, state restoration, and failure modes on spotty mobile connections.
• Behavioral and bar-raiser: ownership, cross-team work, how you handle production incidents, and how you reason about user trust on a money app.

The loop rewards candidates who write Kotlin like Kotlin (not Java with `val`), who reach for coroutines and Flow without ceremony, and who can articulate why they would or would not adopt a particular library. Cash App in particular is explicit in its careers materials about expecting strong Android fundamentals: lifecycle, process death, view systems, and the actual semantics of Android's main thread.

Compensation by level

Block trades publicly, so equity is in real NYSE-listed shares of SQ rather than private RSUs. The numbers below are pulled from Levels.fyi self-reported offers and refreshes; they are directional and should be validated with a recruiter for current ranges.

• L3 / SE I (entry): roughly $170K-$210K total, with a small RSU grant.
• L4 / SE II (mid): roughly $230K-$300K total.
• L5 / Senior: roughly $320K-$420K total, with equity becoming the dominant component above base.
• L6 / Staff: roughly $450K-$600K+ total in recent reports.
• L7 / Principal: $600K-$900K+ total, sparse data points.

Two notes. First, Levels.fyi data for Block specifically is mixed across Cash App, Square, Tidal, and Spiral, so you will see meaningful variance by org and by hire date depending on the SQ stock price at grant. Second, Android-specific medians are thinner than the general software-engineer pool; treat the ranges as ladder bands rather than precise role bands.

Tech stack: Workflow + Compose + Retrofit + Moshi (all Square OSS)

The Android stack at Block is unusually self-consistent because so much of it is built on libraries Square itself maintains in the open. The picture below stitches together public references from the Square developer blog, the Block OSS page (block.xyz/oss), and the GitHub repositories themselves.

• Language: Kotlin first, with new code essentially all Kotlin and remaining Java concentrated in older modules. Coroutines and Flow are the default async primitives.
• UI: Jetpack Compose is the forward direction for new screens; legacy screens still ship with the View system, particularly in older Point of Sale flows.
• Architecture: Workflow (github.com/square/workflow-kotlin) is Square's own state-management framework. Workflows model UI state as a tree of pure state machines that render to view models, which the rendering layer then maps to either Compose or View output. It is heavily used in Point of Sale and is one of the more distinctive things candidates encounter on day one.
• Networking: Retrofit (github.com/square/retrofit) over OkHttp, with Moshi for JSON. All three are Square OSS, and the team uses them the way they were designed to be used; idiomatic interfaces, suspending functions, and Kotlin code generation rather than reflection.
• Dependency injection: Anvil with Dagger underneath, which is again Square's own compiler plug-in. Anvil eliminates most of Dagger's component boilerplate.
• Memory and stability: LeakCanary on every engineer's debug build, plus internal crash reporting wired into the standard release pipeline.
• Build: Gradle with Kotlin DSL, heavy modularization (Cash App and Square POS are both very large multi-module projects), and Bazel in some corners for build performance.
• Testing: JUnit + Truth assertions for unit tests, Robolectric for view tests, and a mix of Espresso and screenshot-diff testing for UI regression.

The stack matters for candidates because it is unusually opinionated and unusually open. You can read the Workflow source, the Retrofit source, and the Moshi source before your onsite, and that work is genuinely useful preparation; much of the rest of the industry only learns these libraries by importing them.