I never set out to become a real-time systems engineer. But looking back at fifteen years of building infrastructure, every role pushed me deeper into the spaces between packets, focusing on the milliseconds of latency that separate good systems from failure.

Learning What Reliability Actually Means

My education in real-time systems was kickstarted at Comcast. As a Senior Reliability Engineer, I was responsible for keeping Xfinity Business Internet running and ensuring NBC Sports stayed stable during national broadcasts. The stakes were immediate. When millions of viewers tune in for Sunday Night Football, there is no buffer, no retry, no “we’ll fix it in the next sprint.” The system works or it doesn’t, and everyone knows which one happened.

I built event-driven monitoring and auto-remediation systems using Kafka, RabbitMQ, and Redis. We cut Xfinity Business Internet downtime by half. I drove enterprise-wide Splunk adoption, wiring automated playbooks that slashed incident detection and resolution time. But the real lesson wasn’t technical. It was understanding that observability isn’t a feature you bolt on later. It’s the foundation everything else depends on.

That lesson would follow me everywhere.

The Unforgiving and World of Voice

From Comcast I moved to TelTech, the company behind Robokiller. If you’ve ever wondered why voice infrastructure is considered hard, spend a day debugging complex SIP routing issues while your carriers point fingers at each other.

Voice is different from other backend work. You can buffer video. You can retry HTTP requests. But voice is now or never. Every millisecond of latency accumulates into awkward conversation. One-sided audio, garbled codecs, or even modest jitter destroying comprehension. Packet loss that would be invisible in a web app becomes a dropped syllable that changes the meaning of a sentence.

At TelTech I worked on the infrastructure that powered Robokiller’s call blocking for 12 million users. The system processed over 10 million minutes monthly, analyzing calls in real-time to determine if they were spam. Sub-second response times weren’t a nice-to-have. They were the product.

I learned SIP, RTP, and the weird edge cases that come with bridging VoIP to the legacy telephone network. Carriers use different codecs, strange signaling headers, and inconsistent DTMF handling. The modern VoIP world and the old PSTN world don’t speak the same language, and someone has to translate.

That someone became me when I cofounded a telephony startup as CTO. We rebuilt the voice infrastructure from scratch, creating a mobile SDK that handled SIP and RTP natively. This gave us full control over call routing regardless of which carrier or provider sat upstream. When you own the protocol layer, you’re not dependent on anyone’s roadmap. You can optimize the entire path, swap providers without rewriting the app, and debug issues end-to-end instead of opening tickets with three different vendors who all blame each other.

The technical challenge was real, but the insight was strategic: vendor flexibility isn’t just about cost savings. It’s about owning your own destiny.

Same Problems, Different Domain

After the telephony startup, I joined Take-Two Interactive to lead backend platform engineering for their mobile games division, including titles like Two Dots. Different industry, same fundamental demands.

Gaming has its own version of “now or never.” When a player taps the screen, they expect immediate feedback. When an engagement event fires, it needs to reach the analytics pipeline instantly or the data loses value. I built an event-driven engagement platform that doubled daily session frequency and drove a 20% revenue increase through improved player retention.

The work confirmed something I’d suspected: the pattern recognition transfers. Real-time voice, real-time gaming, real-time anything. The protocols differ but the physics of latency are universal. You learn to think in milliseconds, to trace packets through systems, to find the bottleneck that’s adding 50ms nobody accounted for.

Hardware Meets Software at the Edge

Then came Vapor IO, where everything got harder.

Vapor IO operates edge data centers, computing infrastructure deployed at the base of cell towers and in urban cores rather than centralized cloud regions. The pitch is simple: put compute closer to users and latency drops. The reality is complicated. Edge environments have thermal constraints, power limitations, and connectivity that makes cloud networking look trivial.

I joined as VP of Engineering and inherited Synse, a proprietary telemetry system built to monitor the physical infrastructure. Temperature sensors, power distribution units, fan controllers. Hardware that doesn’t speak HTTP or know what Kubernetes is.

Synse worked. We ran it across 30+ edge data centers, collecting telemetry from hardware that ranged from standard server racks to experimental GPU clusters. I helped build Zero Gap AI, a platform we developed with NVIDIA using GH200 Grace Hopper systems for AI workloads at the edge. Observability wasn’t optional when you’re running $50,000 GPUs in a cell tower enclosure with constrained cooling.

But Synse was proprietary. It solved our problems but created its own silo. The more I worked with it, the more I came to appreciate what open standards offer: interoperability, community knowledge, vendor flexibility. The same lesson I’d learned in telephony, showing up in a different form.

I started embracing OpenTelemetry, the open standard for observability data. Not because Synse was bad, but because I’d seen this pattern before. Proprietary systems create lock-in. They make you dependent on internal roadmaps. They isolate you from the broader ecosystem of tools and talent.

The shift wasn’t about abandoning what we’d built. It was about recognizing that the best infrastructure connects systems rather than creating new walls between them.

What Comes Next

Fifteen years of building real-time systems. Reliability engineering at Comcast. Voice infrastructure at TelTech and my own startup. Event systems at Take-Two. Edge telemetry at Vapor IO. Each role taught me something about latency, observability, and the value of owning your own stack while remaining compatible with everyone else’s.

After fifteen years of connecting systems that weren’t designed to talk to each other, I’ve started to see infrastructure differently. The best tools don’t create new kingdoms. They build bridges.

Last month I built a markdown editor for Telescopo, a highly requested feature. Took six hours. Live preview, syntax highlighting, the works. It worked `fine`.

I decided to scrap ALL of it.

Not because it was broken. It worked. But sitting there, looking at it, I felt nothing. Just another text box. Another cursor blinking. Another editor in a world drowning in editors.

My app renders LaTeX equations instantly. It makes PlantUML diagrams appear like magic. It has beautiful and fun themes with animated gradients that makes reading specs at 2 AM actually enjoyable. (Highly recommend the “Bad Command” or “Cyberpunk” themes!) And here I was, adding a boring text box that looked like every other text box since 1984.

So I killed it. Kept the new bottom navbar I’d designed for it though. That was actually beautiful.

The AI Name Drop

Since we launched it, Telescopo AI had “AI” in the name. Never had any AI features. I just liked how it sounded (and it’s a nice complementary name to my Mobile AI Headshots app - Telefoto AI).

Last week someone messaged me: “Drop the AI from the name. I hate AI buzzword bullshit.”

You know what’s funny? Version 3 just shipped with actual AI. On-device document summarization using Apple Intelligence. Real AI that does real work on your actual Mac. And that’s exactly when I dropped “AI” from the name.

Now it’s just Telescopo. Now that it actually has AI.

The LaTeX Flex

Everyone renders LaTeX the same way. Load MathJax. Wait. Process. Wait. Display. Wait some more if you want to change the font size. Start over if you switch themes.

I built my own LaTeX engine from scratch. Not because I’m smarter than the MathJax team. But because I’m more obsessive about one specific thing: speed.

Telescopo renders LaTeX instantly. Not quickly. Instantly. Change fonts in real-time. Switch from Light to Cyberpunk theme and watch the equations recolor themselves smoothly. Zoom with your trackpad and see the math scale perfectly.

Nobody else does this. Not because they can’t. Because they don’t care enough. They ship MathJax and call it done. That’s fine. But fine bores me.

The Cloud Nobody Asked For

“You need cloud sync,” a fellow app developer told me. “Table stakes for document apps.”

Sure. I could add it. Firebase, iCloud Kit, whatever. Sync your documents across devices. Collaborate with teammates. Share with anyone.

But here’s what actually happens: you open Telescopo because Preview choked on your 500-page PDF. You need to read this paper right now. You don’t need to sync it. You need to read it. Fast. Beautiful. Now.

Every feature I don’t build makes the features I do build better. No sync means instant opening. No accounts means no login screens. No cloud means your confidential technical docs stay on your Mac.

The 4MB Obsession

Telescopo is 4MB. VS Code is 370MB. I could make Telescopo bigger. Add frameworks. Include libraries. Bundle dependencies. Make my life easier.

But 4MB is a choice. It means I write my own LaTeX engine instead of embedding someone else’s. It means I optimize every image. It means I question every dependency.

There’s actually a single unoptimized PNG image in there right now that bugs me. I could probably get it under 2MB if I fixed it. I probably will. Not because anyone cares. Because I care.

The Perfect Reading Chair

Someone asked why Telescopo doesn’t compete with Obsidian or VS Code. Here’s why: they’re building Swiss Army knives. I’m building the world’s best reading chair.

You don’t edit in a reading chair. You don’t sync reading chairs to the cloud. You don’t need a subscription for your reading chair. You just need it to be comfortable, beautiful, and always work.

That’s Telescopo. It opens documents instantly. It renders them perfectly. It looks beautiful doing it. That’s the entire feature list that matters.

What Actually Ships

Version 3 just landed with a completely rebuilt bottom navbar. Subtle colors that match each theme. Tighter controls. Better popovers. Apple Intelligence integration that feels native.

None of these are “features” in the traditional sense. You can’t put “better navbar” on Product Hunt. But when you’re reading documentation at midnight, these details matter more than any editor ever could.

The Boredom Filter

Here’s my development process: build something. Use it for a week. If it bores me, delete it.

The editor bored me. Cloud sync bored me. Collaboration features bore me to tears.

But making LaTeX render instantly? That’s fun. Creating smooth theme transitions with Metal? That’s interesting. Building a Cyberpunk theme with animated gradients? That makes me smile every time I open a document. I was so happy using the Cyberpunk theme that I wrote Cyberspace and Bad Command themes just to have more choices in fun animated themes to choose from.

If it doesn’t make me excited to use my own app, it doesn’t ship.

The Next Thing

People keep sending feature requests. Add an editor. Add annotations. Add cloud sync. Add collaboration.

Maybe I’ll build them. Probably, I’ll delete them. The editor needs to be as beautiful as the viewer or it doesn’t belong. The sync needs to be invisible or it’s just friction. The features need to inspire me or they’re just checkboxes.

Until then, I’ll keep obsessing over the perfect reading experience. Making ePUBs and PDFs open faster. Making themes transition smoother. Making LaTeX render better. We just integrated our Mermaid renderer into Markdown, no reason we can’t start combining our rendering engines into an entirely new format that gives even more power and beauty to viewing technical documents.

Because in a world of bloated apps trying to do everything, there’s something radical about doing one thing perfectly.

Even if it’s just reading technical documents.

Telescopo is available on the Mac App Store, for more information visit www.telescopo.ai

The Original Sin

Telescopo started as Smackdown, a simple markdown viewer for Mac. It did one thing well: it rendered markdown files with nice typography. That was it. 500 lines of Swift code, shipped in a weekend, five bucks on the Mac App Store.

But every time I opened it, I'd think about what else it could do. Not feature creep exactly, more like feature destiny. The code was begging to handle more than just markdown.

The Beauty Principle

Most document viewers look like they were designed by someone who hates both documents and viewers. Gray backgrounds, system fonts, utilitarian interfaces that scream "I am a tool you tolerate." Even Apple's Preview, while functional, feels like it hasn't been touched since 2011.

I wanted Telescopo to feel different. When you open a Python file, the syntax highlighting should be gorgeous. When you're reading an EPUB novel, the typography should be perfect. When you're reviewing a PDF at midnight, dark mode should feel like it was designed by someone who actually uses dark mode.

So I built three themes. Light for normal humans. Dark for developers. And Cyberpunk for... well, for me initially, but turns out a lot of people love subtle animations while they read.

The Constraint Advantage

Here's a decision that shaped everything: Telescopo is a viewer, not an editor. You can't modify files. You can't annotate PDFs. You can't edit markdown.

This constraint was liberating. Instead of building yet another mediocre text editor, I could focus entirely on the reading experience. How fast can a PDF open? How smooth can scrolling be? How quickly can you navigate between chapters in an EPUB?

When you're not worried about saving changes or managing undo states, you can use all that computational power for one thing: making viewing files feel incredible.

Native or Nothing

I wrote Telescopo in Swift, using AppKit, optimized with Metal. No Electron. No web views. No cross-platform frameworks.

This matters more than you'd think. Native means when you press Command-O, the file dialog appears instantly. When you scroll, it follows your trackpad perfectly. When you pinch to zoom, it responds immediately. These milliseconds add up to something that feels right.

Metal acceleration means a 1000-page PDF scrolls like butter. It means the Cyberpunk theme can have subtle animations without destroying your battery. It means switching between tabs is instant, not "pretty fast for a document viewer."

The Tab Revolution

For some reason, document viewers hate tabs. Preview doesn't have them. Most PDF readers don't have them. It's 2025 and we're still opening seventeen windows to compare files.

Building proper tabs was harder than I expected. Not just the UI, but making them feel native. Command-T for new tab. Command-W to close. Command-Shift-[ and ] to switch. Dragging tabs between windows. All the muscle memory Mac users have from Safari and Terminal.

But here's what made it worth it: watching someone realize they can have their Python script in one tab, the API documentation in another tab, and flip between them instantly. That moment of "oh, this is how it should work" makes the weeks of implementation worth it.

Supporting Everything

The feature that gets the most reactions: Telescopo opens 70+ file formats. PDFs, EPUBs, markdown, Python, Swift, Rust, JSON, CSV, even Mermaid diagrams render inline.

Each format required its own parser, its own optimizations, its own edge cases. Python files need different syntax highlighting than Swift. EPUBs need chapter detection. CSVs need column recognition. Mermaid diagrams need to render without launching a browser.

But when someone drops any file onto Telescopo and it just works, that surprise and delight is worth every parser I had to write.

The Free Upgrade

When I released Telescopo, I had a choice. Charge existing Smackdown users for the upgrade (it was 30x more code, after all) or give it to them free.

I made it free. Not because I'm running a charity, but because surprising users with unexpected value creates something money can't buy: genuine enthusiasm. Those users became my best advocates. They wrote reviews. They told friends. They posted on forums.

Turns out, generosity is good business.

What I Learned

Beautiful software doesn't mean ornamental. It means thoughtful. Every animation in Telescopo has a purpose. Every color was chosen deliberately. Every interaction was refined until it felt invisible.

Fast is a feature. Not "fast enough" but genuinely, surprisingly fast. When a massive PDF opens instantly, users notice. When search completes before they finish typing, they remember.

Constraints create clarity. By refusing to be an editor, Telescopo became a better viewer than apps trying to do both.

Native matters. In a world of Electron apps and web wrappers, native Mac software stands out just by feeling correct.

The Point

Software can be functional and beautiful. It can be powerful and simple. It can be professional and have a cyberpunk theme with subtle animations.

We spend hours every day looking at documents, code, and data. Those hours should be pleasant. The tools we use every day should bring us joy, not just utility.

That's why I spent three months on that cyberpunk theme. Because at 2 AM, when you're debugging production issues, reading through logs and documentation, you deserve software that makes you smile.

Even if it's just a document viewer.

Telescopo is available on the Mac App Store for free for Markdown. For anyone that wants a few additional features, you can unlock LaTeX, Mermaid, SVG, ePub, PDF, and 70+ additional formats along with six themes, and AI summarization and much more with Telescopo Pro for only $19.99 (20% off the $24.99 price for a limited time). Telescopo is just a native Mac app that makes reading files beautiful. www.telescopo.ai