- We offer certified developers to hire.
- We’ve performed 1500+ Web/App/eCommerce projects.
- Our clientele is 1000+.
- Free quotation on your project.
- We sign NDA for the security of your projects.
- Three months warranty on code developed by us.
Theater is no longer limited to a physical box office, printed schedules, and customers standing in queues to purchase tickets. Modern audiences expect to discover shows, explore venues, check seat availability, compare ticket prices, reserve seats, make secure payments, receive digital tickets, and manage their bookings directly from a smartphone.
That shift creates a strong opportunity for businesses that want to build a theater app.
A theater app can serve many different business models. It can be a digital platform for a single theater, a multi venue ticket booking marketplace, a theater chain application, a performing arts discovery platform, or a comprehensive entertainment ecosystem that combines theater listings, ticketing, memberships, food ordering, merchandise, loyalty programs, reviews, and personalized recommendations.
However, building a successful theater app is not simply a matter of creating a few screens for show listings and adding a payment gateway. The application must coordinate schedules, performances, venues, seating layouts, ticket inventory, customer accounts, payments, cancellations, notifications, digital tickets, promotions, and administrative operations.
The most important question is therefore not only “How do I build a theater app?” but also “What theater experience am I trying to digitize?”
A strong development strategy starts with the business model, target audience, theater workflow, ticketing logic, user experience, technology architecture, security requirements, monetization strategy, and long term scalability.
This guide explains the entire process of theater app development, from initial planning through architecture, UI and UX design, feature development, testing, deployment, maintenance, and future expansion.
A theater app is a mobile or web based software platform that allows users to discover and interact with theatrical entertainment digitally.
Depending on the product strategy, a theater application may allow users to:
For theater operators, the application can provide:
The difference between a basic theater booking application and a sophisticated theater platform is primarily the depth of operational integration.
The demand for digital entertainment experiences has changed how customers interact with venues.
Customers increasingly expect convenience. They want to discover entertainment without calling a box office or visiting a theater website. They also expect digital confirmation, transparent pricing, simple seat selection, and quick payment.
For theater businesses, an application can provide a direct relationship with customers.
Instead of depending entirely on third party marketplaces, a theater can use its own application to collect customer preferences, understand purchasing behavior, promote upcoming productions, and encourage repeat visits.
A theater app can provide several business advantages.
A theater application gives the business a direct communication channel.
The operator can notify users about:
This can be considerably more flexible than relying exclusively on traditional advertising.
The fewer steps customers need to complete, the easier it becomes to convert interest into bookings.
A well designed theater app can allow a customer to:
The entire journey can happen within minutes.
A theater application can generate useful first party data.
For example, a theater operator can analyze:
This information can support better programming and marketing decisions.
A digital platform can reduce manual work related to:
Automation can allow theater staff to focus more heavily on customer service and production operations.
Before development begins, determine what type of theater app you want to create.
Different models require different features, workflows, and technology architectures.
A single venue can build an application dedicated to its own performances.
This is one of the simplest theater app models.
Typical functionality includes:
The application can strengthen the theater’s brand and encourage direct ticket sales.
A theater chain application supports multiple venues under one brand.
Users can select:
The backend must support multiple venue configurations while maintaining a consistent customer experience.
This model requires stronger venue management capabilities.
A marketplace can aggregate performances from multiple independent theaters.
Users can search for performances across different venues.
The platform may earn revenue through:
This model introduces more complexity because each participating theater may have different ticketing rules, seating systems, pricing structures, cancellation policies, and inventory systems.
A theater discovery application can focus more heavily on content than ticketing.
Users can discover:
Ticket purchases can either occur inside the app or through integrated external ticketing systems.
A membership focused application can provide benefits to subscribers.
Potential features include:
This model is particularly useful for organizations with an established customer base.
Not every theater app needs to be customer facing.
A theater management application can be designed for staff and administrators.
It can support:
A theater business may use both a customer application and an internal management platform.
A larger product can combine all these capabilities.
The ecosystem might include:
This approach creates a complete digital theater operation.
Technology should follow the business model rather than the other way around.
Before hiring developers or choosing a technology stack, answer several fundamental questions.
Your users may include:
Each group has different expectations.
A family booking children’s theater may care about seating and accessibility.
A frequent theatergoer may care about loyalty rewards.
A tourist may care about location, language, reviews, and easy digital ticketing.
A theater operator may care about occupancy and revenue analytics.
A strong product should have a clear problem statement.
For example:
“Customers in our city struggle to discover local theater performances and purchase tickets through a fragmented booking process.”
Or:
“Our theater chain needs a direct digital channel that simplifies ticket purchasing and improves customer retention.”
The problem statement should guide feature prioritization.
Possible revenue models include:
A business model should be defined before the payment and accounting architecture is finalized.
A theater application can contain dozens of features, but the following capabilities are usually central to the customer experience.
Customers should be able to create accounts using:
The registration process should remain simple.
If users are forced to complete a long form before exploring performances, conversion can suffer.
A practical approach is to allow browsing without registration and require authentication when necessary for booking.
A customer profile can contain:
Users should be able to modify their personal information easily.
The home screen should help customers quickly discover relevant performances.
Potential sections include:
The exact layout should be determined through user research and testing.
Search is especially important when a platform contains many performances.
Users may search by:
A robust search system should tolerate spelling variations and partial terms.
Useful filters include:
Filters help users move from a broad catalog to a relevant result quickly.
Every performance should have a comprehensive detail page.
It may include:
A strong performance detail page reduces uncertainty before purchase.
Each venue can have its own profile containing:
Maps can help customers estimate travel time.
A theater app needs a scheduling engine.
The system should support:
Schedule changes should be propagated to relevant customers automatically.
Seat inventory is one of the most technically sensitive components of a theater ticketing application.
The application must prevent two customers from purchasing the same seat simultaneously.
A common flow is:
If payment fails or the reservation expires, held seats should return to inventory.
The seat map should be visually intuitive.
Different seat categories can include:
The map should clearly distinguish:
Color should not be the only method of communicating status because accessibility matters.
Icons, labels, patterns, or text states can provide additional context.
The booking process should capture:
The system should generate a unique booking reference.
A streamlined checkout process can contain:
Avoid unnecessary form fields.
A theater application needs secure payment processing.
Depending on the target market, payment options can include:
The application should never unnecessarily store sensitive card information.
Payment processing should be delegated to appropriately secured payment providers.
After successful payment, users should receive a digital ticket.
A digital ticket may contain:
QR codes can support faster admission.
At the theater entrance, staff can scan the ticket.
The validation system should verify:
The system should immediately record successful admission.
Customers should be able to view:
This creates a convenient record of customer activity.
Cancellation rules vary by theater and performance.
The platform should support configurable policies.
For example:
The rules should be clearly displayed before purchase.
Notifications can be used for:
Notifications should provide useful information rather than overwhelming customers.
Some customers may prefer email or SMS.
Important transactional messages can include:
Marketing communication should follow applicable consent and privacy requirements.
Once the core experience is stable, additional capabilities can differentiate the product.
A recommendation engine can suggest performances based on:
Machine learning can eventually improve these recommendations.
However, a recommendation engine does not need sophisticated artificial intelligence at launch.
A rule based recommendation system can be sufficient for an MVP.
A loyalty program can reward customers for:
Rewards can include:
A membership system can support multiple tiers.
For example:
Each tier can have different benefits.
The backend should be designed so membership rules are configurable rather than hardcoded.
The platform can support:
The promotion engine should include eligibility rules and usage limits.
More sophisticated theater platforms may implement demand based pricing.
Prices can potentially vary according to:
Dynamic pricing should be transparent to users.
The app can allow customers to order refreshments.
Possible features include:
This can increase revenue per customer.
Theater organizations can sell:
The merchandise system can operate as an integrated commerce module.
Users can review:
A moderation system should be implemented to prevent abusive or fraudulent content.
Users can share performances through:
Deep links can take recipients directly to the relevant performance page.
Customers can add booked performances to their calendars.
The calendar event can contain:
Location functionality can help customers find nearby venues and performances.
Users can search by:
Location permissions should be requested only when needed.
A customer application is only one side of the system.
The administrative platform is equally important.
The dashboard should provide an overview of:
Charts and summaries can help managers identify operational issues.
Administrators should be able to:
Administrators can configure:
The seating system should allow authorized staff to:
A visual seat map editor can make administration easier.
Administrators should control:
Role based permissions should limit who can change financial settings.
Staff should be able to search bookings using:
Refund workflows should clearly record:
Useful theater analytics include:
Analytics should support business decisions rather than simply display large quantities of data.
The theater app should be designed around the customer’s goal.
The most common goal is simple:
“Find a performance I want to see and buy a good seat quickly.”
Every screen should support that journey.
A typical customer journey can look like this:
Reducing friction at each step can improve conversion.
Because many theater customers will use smartphones, the application should be designed mobile first.
Important considerations include:
The interface should also work well on different screen sizes.
Accessibility should be included from the beginning.
Consider:
Accessibility is both a usability requirement and an important part of inclusive digital product design.
One of the most common mistakes is trying to build every feature at once.
A better strategy is to build a minimum viable product.
A theater booking MVP may include:
Advanced functionality can come later.
The MVP should answer a fundamental question:
“Can customers successfully discover, purchase, and use a theater ticket through the application?”
If the answer is yes, the product has a useful foundation.
A structured development roadmap reduces risk.
Define:
Document:
Study:
Create:
Define:
Develop:
Test:
Prepare:
Start with a controlled launch.
Monitor:
Use real user behavior to determine which features should be improved or added.
Technology selection should reflect the expected scale and business requirements.
There is no single universally correct technology stack.
A small theater may require a relatively simple architecture.
A national theater marketplace may require distributed systems, advanced caching, sophisticated search, high availability, and complex inventory management.
Possible approaches include:
Native development can provide excellent platform integration.
Cross platform development can reduce duplicated implementation when the product needs both iOS and Android applications.
The appropriate choice depends on the team, budget, performance requirements, existing systems, and long term product strategy.
A theater backend can be implemented using technologies such as:
The most important factor is not the popularity of the language.
Architecture quality, engineering experience, security, maintainability, testing, and operational reliability matter considerably more.
A theater application typically needs a relational database for transactional data.
Potential relational technologies include:
A relational database is particularly useful for:
Additional technologies may be introduced for specialized requirements.
For example:
A cloud platform can provide:
Potential cloud environments include:
The right choice depends on the organization’s existing ecosystem and technical expertise.
A practical architecture may consist of several layers.
This includes:
The API layer connects client applications to backend services.
It may expose:
This layer handles:
This layer manages:
Integrations may include:
A new theater application does not necessarily need microservices.
A modular monolith can be an excellent starting architecture.
Modules might include:
As the platform grows, individual services can be separated where there is a clear operational reason.
Microservices may eventually be useful for large systems with independent scaling requirements.
However, introducing microservices too early can increase:
Architecture should match actual business scale.
The booking engine is arguably the most important backend component.
It must maintain consistency under concurrent demand.
Imagine that two customers select the same seat at almost exactly the same time.
The application cannot allow both customers to successfully purchase it.
The backend therefore needs a reservation mechanism.
A simplified lifecycle is:
Available → Held → Payment Pending → Confirmed
Or, when the customer does not complete payment:
Available → Held → Expired → Available
When a ticket is canceled:
Confirmed → Canceled
The exact states should be formally documented.
When a user selects a seat, the application can temporarily reserve it.
The hold should have an expiration period.
For example, a system might allow a short checkout window.
The exact duration should be determined based on:
The important principle is that temporary holds must expire reliably.
Concurrency control prevents duplicate booking.
Possible techniques include:
The implementation should be carefully tested under high concurrent traffic.
Payment and booking APIs should support idempotent operations where appropriate.
Suppose a customer’s network connection fails after payment.
The mobile app may retry the request.
Without idempotency, a retry could accidentally create duplicate bookings.
An idempotency key can help the backend recognize repeated requests.
Payment systems require particular attention.
The application should distinguish between:
Do not treat the presence of a client side “success” message as proof that money was received.
The backend should verify payment status through trusted mechanisms.
Potential scenarios include:
Each state should have a defined recovery path.
A theater platform can have multiple user types.
For example:
Role based access control can ensure users access only the functions appropriate to their responsibilities.
A staff member who can validate tickets should not necessarily be allowed to modify payment configuration.
The application may process sensitive customer information.
Security measures should include:
Sensitive payment information should be handled according to applicable payment security requirements.
A theater application may collect:
A privacy strategy should define:
Privacy requirements vary by market, so legal review should be included in the product planning process.
A theater app may use REST APIs or GraphQL.
Typical REST endpoints might conceptually include:
The exact API structure should be designed around resources and business workflows.
API versioning can help support future changes.
Seat availability can become stale if it is not updated.
A user might open a seat map and see a seat as available while another customer has just purchased it.
Possible approaches include:
The best approach depends on the expected scale and product requirements.
Real time communication can also support:
Basic search can use database queries.
A larger marketplace may benefit from a dedicated search engine.
Search can support:
Search relevance should be tested using realistic customer queries.
A basic recommendation engine can use rules such as:
“If a user frequently books musicals, show popular musicals near the user’s preferred location.”
A more advanced system can consider:
Machine learning should be introduced when enough data exists to justify the additional complexity.
A theater application can have several notification channels.
Useful for:
Useful for:
Useful for:
A notification service should centralize delivery logic.
The admin interface can be built as a web application.
Useful dashboard modules include:
The dashboard should prioritize operational tasks over decorative charts.
Analytics should be designed before launch.
Useful product metrics include:
A funnel might look like:
Visitors → Performance Views → Showtime Selection → Seat Selection → Checkout → Payment → Confirmed Booking
Analyzing each stage can reveal where customers abandon the process.
The exact team depends on scope.
A typical team may include:
For a smaller MVP, several responsibilities can be combined.
When selecting a development partner or internal team, evaluate more than portfolio screenshots.
Look for evidence of experience with:
Ask potential developers to explain how they would prevent double booking.
That question can reveal whether they understand the most important technical challenges.
A disciplined development workflow can follow:
Agile development can allow teams to release functionality incrementally.
The cost of theater app development varies significantly.
There is no universal price because the scope can range from a basic single venue application to a large multi theater marketplace.
The major cost drivers include:
A simple theater app may require a relatively modest development budget.
A sophisticated platform with multiple venues, complex ticketing, loyalty, personalization, food ordering, and enterprise integrations can require a substantially larger investment.
This includes:
This includes:
Costs increase when separate native applications are developed for iOS and Android.
Backend development can become one of the largest components because ticketing requires complex transactional logic.
A comprehensive management platform requires substantial development effort.
Examples include:
Testing should not be treated as an optional expense.
Operational costs can include:
Post launch maintenance is necessary because:
A useful planning model is to classify the product into three broad categories.
A basic application may include:
This is suitable for validating a focused business concept.
A medium platform may add:
A large platform may include:
The cost can rise considerably because each additional module creates new engineering, testing, security, and operational requirements.
Building for:
requires additional engineering and testing.
International theater platforms may need:
A multi country platform may need:
A simple rectangular seat grid is easier than a theater with:
Each integration adds:
AI based recommendations require:
Cost optimization should not mean cutting essential quality.
Instead, reduce unnecessary complexity.
Validate the product before expanding.
Prioritize the booking journey.
A modular system allows future capabilities to be added without rebuilding the entire platform.
Use reliable managed services where appropriate.
Building a payment processing system from scratch is generally unnecessary for a theater booking product.
Automated tests can reduce regression costs over time.
Reusable UI and backend modules can accelerate development.
Testing is critical because ticketing errors directly affect revenue and customer trust.
A theater application should be tested across multiple dimensions.
Test:
Test scenarios such as:
These scenarios should be tested repeatedly.
Test:
Use sandbox environments where available.
The platform should be tested during high demand.
Consider situations such as:
Load testing can identify bottlenecks before customers encounter them.
Security testing should cover:
A professional security assessment can be appropriate for larger platforms.
Invite real users to complete tasks such as:
“Find a comedy performance this weekend and book two seats.”
Observe where they hesitate.
The goal is not merely to ask whether they like the interface.
The goal is to understand whether they can complete tasks efficiently.
Test using:
Accessibility should be part of regular QA rather than a final checklist item.
Test across:
Responsive behavior should also be tested.
The application should behave gracefully when connectivity is poor.
For example, if a payment is in progress and the network disappears, the app should not incorrectly tell the customer that the booking failed without verifying the backend state.
Before publishing the application, prepare:
The exact requirements vary by platform and jurisdiction.
A successful launch requires more than publishing an application.
Build awareness through:
Start with:
Monitor problems before expanding.
After the core workflow is stable, increase acquisition.
Potential channels include:
A theater app can have multiple revenue sources.
The platform charges a percentage of each booking.
A fixed or variable fee can be added to qualifying bookings.
Customers pay monthly or annually for premium benefits.
Membership can provide:
Theaters or event organizers can pay for increased visibility.
Relevant brands can advertise within the platform.
Advertising should not interfere with the core booking journey.
The platform can earn commission on refreshments sold through the application.
Theater merchandise can create another revenue stream.
If the platform also serves theater operators, venues can pay a recurring software fee.
Acquiring a customer is only part of the business challenge.
The application should encourage repeat bookings.
Recommend performances based on preferences.
Reward repeated behavior.
Give members early access to popular performances.
Customers can receive incentives for introducing new users.
Ask users for feedback.
However, avoid excessive notifications.
Important KPIs include:
A theater application should provide accessible support.
Support channels can include:
Common questions may involve:
A self service help center can reduce support workload.
A performance may be canceled because of:
The application should provide a clear workflow.
When a performance is canceled:
Automation can significantly improve customer communication during disruptions.
Rescheduling is more complex than cancellation.
The system may need to:
These rules should be defined before launch.
Ticketing platforms can face fraudulent activity.
Potential risks include:
Possible controls include:
Fraud controls should be balanced against customer convenience.
A large feature list does not guarantee product success.
The primary booking workflow should work exceptionally well before secondary features are added.
Developers may understand mobile apps but not understand how theaters actually manage:
Operational research is essential.
A double booking can destroy customer trust.
Seat inventory should be treated as a critical transactional system.
Customers should not need to navigate unnecessary screens.
A beautiful customer app is not enough.
Staff need efficient tools to manage performances, bookings, customers, and operational problems.
Accessibility should be incorporated from the beginning.
Security must be part of architecture, development, testing, and operations.
Without analytics, product teams may struggle to understand why customers abandon bookings.
Artificial intelligence is valuable when it solves a real problem.
Do not add an AI recommendation engine simply because it sounds impressive.
Launch is the beginning of the product lifecycle, not the end.
AI can provide meaningful capabilities when implemented carefully.
AI can recommend performances based on customer behavior.
Natural language search could allow users to enter queries such as:
“Find a family friendly musical near me this Saturday evening.”
The system can interpret:
and return relevant results.
A conversational assistant can answer questions about:
The assistant should connect to trusted backend data instead of inventing availability.
Machine learning can help estimate:
Forecasts can support scheduling and marketing.
The system can identify customers who may be interested in a specific performance.
Marketing automation should still respect privacy and consent requirements.
Many established theaters already use software systems.
The new application may need to integrate with:
Integration planning should happen before development.
If an existing system provides APIs, the theater app can synchronize:
Synchronization rules must define:
Without clear ownership of data, systems can become inconsistent.
If your goal is to build a marketplace, additional functionality is necessary.
Partners should be able to:
The platform may need business verification before a theater becomes active.
The dashboard can show:
The platform should calculate:
The marketplace should define when partners receive their funds.
Settlement may be:
Financial workflows should be designed with accounting and legal requirements in mind.
A children’s theater platform may need additional considerations.
Features can include:
Content and marketing should be designed appropriately for younger audiences.
International expansion introduces complexity.
The platform may need:
A globally scalable architecture should avoid hardcoding assumptions about currency, language, or date format.
Localization goes beyond translation.
It can involve:
The interface should be designed for text expansion and different writing systems.
Customers may have weak connectivity when arriving at a venue.
The application can optionally make previously purchased tickets available offline.
However, offline tickets create security considerations.
The system should determine how to validate:
A QR code alone is not automatically secure.
Customers may benefit from adding tickets to device wallets.
The ticket can contain:
Wallet passes can provide convenient access without opening the main application.
Location based functionality could support:
Location tracking should be used carefully.
Always provide transparent explanations for location permissions.
A theater application can eventually become a community.
Potential features include:
Social functionality can encourage organic discovery.
Users can save:
The system can notify them when:
A waitlist can capture demand when a performance sells out.
When seats become available:
The allocation rules should be transparent.
Group bookings can support:
The system may provide:
Group booking can require more sophisticated inventory rules.
Businesses may use theaters for:
A corporate module can provide:
A subscription model can provide recurring access.
Potential plans include:
The subscription system should support:
A strong customer interface depends on reliable backend infrastructure.
The backend should be designed around business invariants.
Examples include:
Writing these rules explicitly helps developers and testers understand the expected behavior.
Theater systems should prepare for failures.
Potential incidents include:
A disaster recovery strategy can include:
A backup that has never been restored should not be assumed to be reliable.
After launch, engineering teams should monitor:
Logs should contain enough information to troubleshoot issues while avoiding unnecessary exposure of sensitive information.
A mature development team can use automated deployment pipelines.
A typical process may include:
This can reduce deployment risk.
A theater application should consider:
Development time depends on the scope.
A basic MVP can be developed significantly faster than an enterprise marketplace.
A rough planning model may look like:
Approximately several weeks may be needed for:
Several weeks may be required depending on the number of workflows.
A focused MVP can require several development cycles.
Features such as:
can substantially extend the timeline.
Testing, store review, deployment preparation, and soft launch should be included in the overall schedule.
Rather than promising an arbitrary launch date, estimate based on the actual feature backlog and technical dependencies.
A theater business does not necessarily need to build every component itself.
Some capabilities can be purchased or integrated.
Potential areas include:
Custom development should focus on capabilities that create competitive differentiation.
For example, a theater company may want to own its:
while using established infrastructure for commodity services.
The answer depends on strategic goals.
Existing software may be appropriate when:
Custom development may be appropriate when:
A hybrid approach is also possible.
If outsourcing development, evaluate potential partners based on technical and business capability.
Look for:
Ask for a technical explanation of:
A partner that can explain these areas clearly is more likely to understand the actual complexity of theater software.
Before signing a development agreement, ask:
The theater application market can evolve beyond simple ticket booking.
Several technologies may shape the next generation of theater platforms.
AI can improve:
AR could help users:
Digital theater experiences may complement physical attendance.
Connected venues may integrate applications with:
Predictive models may help operators anticipate:
A sustainable roadmap might look like this.
Focus on:
Add:
Add:
Add:
Add:
Add:
Technology is important, but product success depends on more than technology.
A successful theater application should provide:
The application should solve a real customer problem better than existing alternatives.
Customers should not have to fight the interface.
A displayed seat should reflect actual inventory as closely as technically possible.
Booking and payment logic should be treated as critical infrastructure.
Theater staff need powerful but understandable tools.
Even if the first release supports one venue, avoid architectural decisions that make future expansion unnecessarily difficult.
Use analytics to understand customer behavior.
Inclusive design improves the experience for many users.
Security should not be bolted on immediately before launch.
An MVP can provide valuable evidence before significant investment in advanced capabilities.
A complete theater app can be organized into the following ecosystem.
Before development:
During design:
During development:
Before launch:
After launch:
Building a theater app is fundamentally a combination of digital ticketing, entertainment discovery, venue operations, payments, customer engagement, and data management.
The simplest version can focus on helping customers discover performances and purchase tickets. A more advanced platform can become an end to end theater ecosystem supporting multiple venues, memberships, loyalty programs, food ordering, merchandise, personalized recommendations, corporate bookings, partner management, and advanced analytics.
The most important part of theater app development is not the number of features included in the first release. It is the reliability and simplicity of the core experience.
Customers should be able to discover a performance, understand what they are purchasing, select a suitable seat, complete payment securely, receive a valid ticket, and enter the theater without unnecessary friction.
Behind that simple experience is a sophisticated technical foundation.
The platform must maintain accurate seat inventory, handle concurrent bookings, synchronize payment states, protect customer information, manage refunds, deliver notifications, support theater staff, and remain reliable during periods of high demand.
For this reason, successful theater app development begins with product strategy and operational research before moving into UI design and programming.
A sensible development path is to define the business model, identify the target audience, document theater workflows, prioritize the MVP, design the customer journey, create a scalable architecture, build the booking engine carefully, integrate secure payments, test difficult edge cases, launch with a controlled audience, and use real customer behavior to guide future development.
The best theater applications are not simply digital versions of a box office. They become convenient platforms through which audiences discover entertainment, build relationships with theaters, manage bookings, receive personalized experiences, and return for future performances.
If the product is planned around real customer needs and supported by reliable engineering, a theater app can evolve from a basic ticket booking tool into a long term digital platform for the entire theater experience.
Get cost, timeline & technical suggestions within 24 hours.
